Graze\Gigya\Test\Unit\Validation\UidSignatureValidatorTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	4
Bugs	3	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	5	1
A	tearDown()	0	4	1
A	testInstanceOf()	0	4	1
B	testUidSignature()	0	34	1
B	testInvalidUidSignature()	0	40	1
B	testInvalidTimestamp()	0	37	1
A	testCanValidationReturnsFalseWhenTheRequiredFieldsAreNotPresent()	0	20	1

<?php
/**
 * This file is part of graze/gigya-client
 *
 * Copyright (c) 2016 Nature Delivered Ltd. <https://www.graze.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license https://github.com/graze/gigya-client/blob/master/LICENSE.md
 * @link    https://github.com/graze/gigya-client
 */

namespace Graze\Gigya\Test\Unit\Validation;

use Graze\Gigya\Exception\InvalidTimestampException;
use Graze\Gigya\Exception\InvalidUidSignatureException;
use Graze\Gigya\Response\ResponseInterface;
use Graze\Gigya\Test\TestCase;
use Graze\Gigya\Validation\ResponseValidatorInterface;
use Graze\Gigya\Validation\Signature;
use Graze\Gigya\Validation\UidSignatureValidator;
use Illuminate\Support\Collection;
use Mockery as m;

class UidSignatureValidatorTest extends TestCase
{
    const SECRET = '8j9h0g-opko;dk]=id0f[sjo';

    /** @var mixed */
    private $signature;
    /** @var UidSignatureValidator */
    private $validator;

    public function setUp()
    {
        $this->signature = m::mock(Signature::class);
        $this->validator = new UidSignatureValidator($this->signature, static::SECRET);
    }

    public function tearDown()
    {
        $this->signature = $this->validator = null;
    }

    public function testInstanceOf()
    {
        static::assertInstanceOf(ResponseValidatorInterface::class, $this->validator);
    }

    public function testUidSignature()
    {
        $response = m::mock(ResponseInterface::class);
        $collection = m::mock(Collection::class);
        $response->shouldReceive('getData')
                 ->andReturn($collection);
        $collection->shouldReceive('has')
                   ->with('UID')
                   ->andReturn(true);
        $collection->shouldReceive('has')
                   ->with('UIDSignature')
                   ->andReturn(true);
        $collection->shouldReceive('has')
                   ->with('signatureTimestamp')
                   ->andReturn(true);
        $collection->shouldReceive('get')
                   ->with('UID')
                   ->andReturn('some_uid');
        $collection->shouldReceive('get')
                   ->with('UIDSignature')
                   ->andReturn('some_signature');
        $collection->shouldReceive('get')
                   ->with('signatureTimestamp')
                   ->andReturn(12345667);
        static::assertTrue($this->validator->canValidate($response));

        $this->signature->shouldReceive('checkTimestamp')
                        ->with(12345667)
                        ->andReturn(true);
        $this->signature->shouldReceive('getUidSignature')
                        ->with('some_uid', 12345667, static::SECRET)
                        ->andReturn('some_signature');
        static::assertTrue($this->validator->validate($response));
    }

    public function testInvalidUidSignature()
    {
        $response = m::mock(ResponseInterface::class);
        $collection = m::mock(Collection::class);
        $response->shouldReceive('getData')
                 ->andReturn($collection);
        $collection->shouldReceive('has')
                   ->with('UID')
                   ->andReturn(true);
        $collection->shouldReceive('has')
                   ->with('UIDSignature')
                   ->andReturn(true);
        $collection->shouldReceive('has')
                   ->with('signatureTimestamp')
                   ->andReturn(true);
        $collection->shouldReceive('get')
                   ->with('UID')
                   ->andReturn('some_uid');
        $collection->shouldReceive('get')
                   ->with('UIDSignature')
                   ->andReturn('some_signature');
        $collection->shouldReceive('get')
                   ->with('signatureTimestamp')
                   ->andReturn(12345667);
        static::assertTrue($this->validator->canValidate($response));

        $this->signature->shouldReceive('checkTimestamp')
                        ->with(12345667)
                        ->andReturn(true);
        $this->signature->shouldReceive('getUidSignature')
                        ->with('some_uid', 12345667, static::SECRET)
                        ->andReturn('incorrect_signature');
        static::assertFalse($this->validator->validate($response));

        $response->shouldReceive('getErrorCode')
                 ->andReturn(0);

        static::setExpectedException(InvalidUidSignatureException::class);
        $this->validator->assert($response);
    }

    public function testInvalidTimestamp()
    {
        $response = m::mock(ResponseInterface::class);
        $collection = m::mock(Collection::class);
        $response->shouldReceive('getData')
                 ->andReturn($collection);
        $collection->shouldReceive('has')
                   ->with('UID')
                   ->andReturn(true);
        $collection->shouldReceive('has')
                   ->with('UIDSignature')
                   ->andReturn(true);
        $collection->shouldReceive('has')
                   ->with('signatureTimestamp')
                   ->andReturn(true);
        $collection->shouldReceive('get')
                   ->with('UID')
                   ->andReturn('some_uid');
        $collection->shouldReceive('get')
                   ->with('UIDSignature')
                   ->andReturn('some_signature');
        $collection->shouldReceive('get')
                   ->with('signatureTimestamp')
                   ->andReturn(12345667);
        static::assertTrue($this->validator->canValidate($response));

        $this->signature->shouldReceive('checkTimestamp')
                        ->with(12345667)
                        ->andReturn(false);
        static::assertFalse($this->validator->validate($response));

        $response->shouldReceive('getErrorCode')
                 ->andReturn(0);

        static::setExpectedException(InvalidTimestampException::class);
        $this->validator->assert($response);
    }

    public function testCanValidationReturnsFalseWhenTheRequiredFieldsAreNotPresent()
    {
        $response = m::mock(ResponseInterface::class);
        $collection = m::mock(Collection::class);
        $response->shouldReceive('getData')
                 ->andReturn($collection);
        $collection->shouldReceive('has')
                   ->with('UID')
                   ->andReturn(true, true, true, false);
        $collection->shouldReceive('has')
                   ->with('UIDSignature')
                   ->andReturn(true, true, false, true);
        $collection->shouldReceive('has')
                   ->with('signatureTimestamp')
                   ->andReturn(true, false, true, true);
        static::assertTrue($this->validator->canValidate($response));
        static::assertFalse($this->validator->canValidate($response));
        static::assertFalse($this->validator->canValidate($response));
        static::assertFalse($this->validator->canValidate($response));
    }
}