TokenManagerTest::manager() - Code Metrics - Inspection of "WIP: Added Phpunit Tests & Travis configuration (#..." - yokai-php/security-token-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3e963f...fbd0cf )

by Yann

created 2017-04-02 13:19 UTC

TokenManagerTest::manager() A

↳ Parent: TokenManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	6
nc	1
nop	0

<?php

namespace Yokai\SecurityTokenBundle\Tests\Manager;

use Prophecy\Prophecy\ObjectProphecy;
use Yokai\SecurityTokenBundle\Entity\Token;
use Yokai\SecurityTokenBundle\Factory\TokenFactoryInterface;
use Yokai\SecurityTokenBundle\InformationGuesser\InformationGuesserInterface;
use Yokai\SecurityTokenBundle\Manager\TokenManager;
use Yokai\SecurityTokenBundle\Manager\UserManagerInterface;
use Yokai\SecurityTokenBundle\Repository\TokenRepositoryInterface;

/**
 * @author Yann Eugoné <[email protected]>
 */
class TokenManagerTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    private $factory;

    /**
     * @var TokenRepositoryInterface|ObjectProphecy
     */
    private $repository;

    /**
     * @var InformationGuesserInterface|ObjectProphecy
     */
    private $informationGuesser;

    /**
     * @var UserManagerInterface|ObjectProphecy
     */
    private $userManager;

    protected function setUp()
    {
        $this->factory = $this->createMock(TokenFactoryInterface::class);
        $this->repository = $this->prophesize(TokenRepositoryInterface::class);
        $this->informationGuesser = $this->prophesize(InformationGuesserInterface::class);
        $this->userManager = $this->prophesize(UserManagerInterface::class);
    }

    protected function tearDown()
    {
        unset(
            $this->factory,
            $this->repository,
            $this->informationGuesser,
            $this->userManager
        );
    }

    protected function manager()
    {
        return new TokenManager(
            $this->factory,
            $this->repository->reveal(),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->informationGuesser->reveal(),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->userManager->reveal()
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        );
    }

    /**
     * @test
     */
    public function it_get_token_from_repository()
    {
        $this->repository->get('unique-token', 'forgot_password')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->shouldBeCalledTimes(1)
            ->willReturn($expected = $this->prophesize(Token::class)->reveal());

        $token = $this->manager()->get('forgot_password', 'unique-token');

        self::assertSame($expected, $token);
    }

    /**
     * @test
     */
    public function it_create_unique_token()
    {
        $token1 = new Token('string', 'jdoe','unique-token-1', 'reset-password',  '+1 day', []);
        $token2 = new Token('string', 'jdoe','unique-token-2', 'reset-password',  '+1 day', []);

        $this->factory->expects($this->exactly(2))
                      ->method('create')
                      ->will($this->onConsecutiveCalls($token1, $token2));

        $this->repository->exists('unique-token-1', 'forgot_password')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->shouldBeCalledTimes(1)
            ->willReturn(true);
        $this->repository->exists('unique-token-2', 'forgot_password')
            ->shouldBeCalledTimes(1)
            ->willReturn(false);

        $this->repository->create($token1)
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->shouldNotBeCalled();
        $this->repository->create($token2)
            ->shouldBeCalledTimes(1);

        $token = $this->manager()->create('forgot_password', 'john-doe');

        self::assertSame($token2, $token);
    }

    /**
     * @test
     */
    public function it_consume_token()
    {
        $token = new Token('string', 'jdoe','unique-token', 'reset-password',  '+1 day', []);

        $this->informationGuesser->get()
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->shouldBeCalledTimes(1)
            ->willReturn(['some', 'precious', 'information']);

        $this->repository->update($token)
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->shouldBeCalledTimes(1);

        $this->manager()->setUsed($token);

        self::assertSame(['some', 'precious', 'information'], $token->getUsedInformation());
        self::assertInstanceOf(\DateTime::class, $token->getUsedAt());
    }

    /**
     * @test
     */
    public function it_extract_user_from_token()
    {
        $token = new Token('string', 'jdoe','unique-token', 'reset-password',  '+1 day', []);

        $this->userManager->get('string', 'jdoe')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->shouldBeCalledTimes(1)
            ->willReturn('john doe');

        $user = $this->manager()->getUser($token);

        self::assertSame('john doe', $user);
    }
}


1			<?php
2
3			namespace Yokai\SecurityTokenBundle\Tests\Manager;
4
5			use Prophecy\Prophecy\ObjectProphecy;
6			use Yokai\SecurityTokenBundle\Entity\Token;
7			use Yokai\SecurityTokenBundle\Factory\TokenFactoryInterface;
8			use Yokai\SecurityTokenBundle\InformationGuesser\InformationGuesserInterface;
9			use Yokai\SecurityTokenBundle\Manager\TokenManager;
10			use Yokai\SecurityTokenBundle\Manager\UserManagerInterface;
11			use Yokai\SecurityTokenBundle\Repository\TokenRepositoryInterface;
12
13			/**
14			* @author Yann Eugoné <[email protected]>
15			*/
16			class TokenManagerTest extends \PHPUnit_Framework_TestCase
17			{
18			/**
19			* @var \PHPUnit_Framework_MockObject_MockObject
20			*/
21			private $factory;
22
23			/**
24			* @var TokenRepositoryInterface\|ObjectProphecy
25			*/
26			private $repository;
27
28			/**
29			* @var InformationGuesserInterface\|ObjectProphecy
30			*/
31			private $informationGuesser;
32
33			/**
34			* @var UserManagerInterface\|ObjectProphecy
35			*/
36			private $userManager;
37
38			protected function setUp()
39			{
40			$this->factory = $this->createMock(TokenFactoryInterface::class);
41			$this->repository = $this->prophesize(TokenRepositoryInterface::class);
42			$this->informationGuesser = $this->prophesize(InformationGuesserInterface::class);
43			$this->userManager = $this->prophesize(UserManagerInterface::class);
44			}
45
46			protected function tearDown()
47			{
48			unset(
49			$this->factory,
50			$this->repository,
51			$this->informationGuesser,
52			$this->userManager
53			);
54			}
55
56			protected function manager()
57			{
58			return new TokenManager(
59			$this->factory,
60			$this->repository->reveal(),
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `reveal` does only exist in `Prophecy\Prophecy\ObjectProphecy`, but not in `Yokai\SecurityTokenBundl...okenRepositoryInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
61			$this->informationGuesser->reveal(),
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `reveal` does only exist in `Prophecy\Prophecy\ObjectProphecy`, but not in `Yokai\SecurityTokenBundl...rmationGuesserInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
62			$this->userManager->reveal()
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `reveal` does only exist in `Prophecy\Prophecy\ObjectProphecy`, but not in `Yokai\SecurityTokenBundl...er\UserManagerInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
63			);
64			}
65
66			/**
67			* @test
68			*/
69			public function it_get_token_from_repository()
70			{
71			$this->repository->get('unique-token', 'forgot_password')
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `get` does only exist in `Yokai\SecurityTokenBundl...okenRepositoryInterface`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
72			->shouldBeCalledTimes(1)
73			->willReturn($expected = $this->prophesize(Token::class)->reveal());
74
75			$token = $this->manager()->get('forgot_password', 'unique-token');
76
77			self::assertSame($expected, $token);
78			}
79
80			/**
81			* @test
82			*/
83			public function it_create_unique_token()
84			{
85			$token1 = new Token('string', 'jdoe','unique-token-1', 'reset-password', '+1 day', []);
86			$token2 = new Token('string', 'jdoe','unique-token-2', 'reset-password', '+1 day', []);
87
88			$this->factory->expects($this->exactly(2))
89			->method('create')
90			->will($this->onConsecutiveCalls($token1, $token2));
91
92			$this->repository->exists('unique-token-1', 'forgot_password')
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `exists` does only exist in `Yokai\SecurityTokenBundl...okenRepositoryInterface`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
93			->shouldBeCalledTimes(1)
94			->willReturn(true);
95			$this->repository->exists('unique-token-2', 'forgot_password')
96			->shouldBeCalledTimes(1)
97			->willReturn(false);
98
99			$this->repository->create($token1)
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `create` does only exist in `Yokai\SecurityTokenBundl...okenRepositoryInterface`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
100			->shouldNotBeCalled();
101			$this->repository->create($token2)
102			->shouldBeCalledTimes(1);
103
104			$token = $this->manager()->create('forgot_password', 'john-doe');
105
106			self::assertSame($token2, $token);
107			}
108
109			/**
110			* @test
111			*/
112			public function it_consume_token()
113			{
114			$token = new Token('string', 'jdoe','unique-token', 'reset-password', '+1 day', []);
115
116			$this->informationGuesser->get()
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `get` does only exist in `Yokai\SecurityTokenBundl...rmationGuesserInterface`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
117			->shouldBeCalledTimes(1)
118			->willReturn(['some', 'precious', 'information']);
119
120			$this->repository->update($token)
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `update` does only exist in `Yokai\SecurityTokenBundl...okenRepositoryInterface`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
121			->shouldBeCalledTimes(1);
122
123			$this->manager()->setUsed($token);
124
125			self::assertSame(['some', 'precious', 'information'], $token->getUsedInformation());
126			self::assertInstanceOf(\DateTime::class, $token->getUsedAt());
127			}
128
129			/**
130			* @test
131			*/
132			public function it_extract_user_from_token()
133			{
134			$token = new Token('string', 'jdoe','unique-token', 'reset-password', '+1 day', []);
135
136			$this->userManager->get('string', 'jdoe')
			0 ignored issues – show Bug introduced 2017-04-01 21:32 UTC by Report Bug Copy Issue Report The method `get` does only exist in `Yokai\SecurityTokenBundl...er\UserManagerInterface`, but not in `Prophecy\Prophecy\ObjectProphecy`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
137			->shouldBeCalledTimes(1)
138			->willReturn('john doe');
139
140			$user = $this->manager()->getUser($token);
141
142			self::assertSame('john doe', $user);
143			}
144			}
145

yokai-php / security-token-bundle

Push — master ( 3e963f...fbd0cf )

TokenManagerTest::manager() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like