Emarref\Jwt\Encryption\AsymmetricTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	110
Duplicated Lines	28.18 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	testGetPrivateKeyUnavailable()	0	4	1
A	testPrivateKey()	0	8	1
A	testGetPublicKeyUnavailable()	0	4	1
A	testPublicKey()	0	8	1
A	testEncryptNoPrivateKey()	0	7	1
A	testEncrypt()	15	15	1
A	testVerifyNoPublicKey()	0	7	1
A	testVerify()	16	16	1

<?php

namespace Emarref\Jwt\Encryption;

class AsymmetricTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    private $algorithm;

    /**
     * @var Asymmetric
     */
    private $encryption;

    public function setUp()
    {
        $this->algorithm = $this->getMockBuilder('Emarref\Jwt\Algorithm\Rs256')->getMock();

        $this->encryption = new Asymmetric($this->algorithm);
    }

    /**
     * @expectedException \RuntimeException
     */
    public function testGetPrivateKeyUnavailable()
    {
        $this->encryption->getPrivateKey();
    }

    public function testPrivateKey()
    {
        $key = 'thisismykey';

        $this->encryption->setPrivateKey('thisismykey');

        $this->assertSame($key, $this->encryption->getPrivateKey());
    }

    /**
     * @expectedException \RuntimeException
     */
    public function testGetPublicKeyUnavailable()
    {
        $this->encryption->getPublicKey();
    }

    public function testPublicKey()
    {
        $key = 'thisismykey';

        $this->encryption->setPublicKey('thisismykey');

        $this->assertSame($key, $this->encryption->getPublicKey());
    }

    /**
     * @expectedException \RuntimeException
     * @expectedExceptionMessage No private key available for encryption.
     */
    public function testEncryptNoPrivateKey()
    {
        $this->algorithm->expects($this->never())
            ->method('sign');

        $this->encryption->encrypt('myvalue');
    }

    public function testEncrypt()
    {
        $unencryptedValue = 'unencrypted_value';
        $encryptedValue   = 'encrypted_value';
        $privateKey       = 'private_key';

        $this->encryption->setPrivateKey($privateKey);

        $this->algorithm->expects($this->once())
            ->method('sign')
            ->with($unencryptedValue, $privateKey)
            ->will($this->returnValue($encryptedValue));

        $this->assertSame($encryptedValue, $this->encryption->encrypt($unencryptedValue));
    }

    /**
     * @expectedException \RuntimeException
     * @expectedExceptionMessage No public key available for verification.
     */
    public function testVerifyNoPublicKey()
    {
        $this->algorithm->expects($this->never())
            ->method('verify');

        $this->encryption->verify('value', 'signature');
    }

    public function testVerify()
    {
        $value          = 'value';
        $signature      = 'signature';
        $publicKey      = 'public_key';
        $encryptedValue = 'encrypted_value';

        $this->encryption->setPublicKey($publicKey);

        $this->algorithm->expects($this->once())
            ->method('verify')
            ->with($value, $signature, $publicKey)
            ->will($this->returnValue($encryptedValue));

        $this->encryption->verify($value, $signature);
    }
}