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

Completed

Pull Request — master (#7)

by Yann

created 2017-04-02 07:40 UTC

TokenManagerTest::setUp() A

↳ Parent: TokenManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	5
nc	1
nop	0

<?php

namespace Yokai\SecurityTokenBundle\Tests\Manager;

use PHPUnit\Framework\TestCase;
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 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 PHPUnit\Framework\TestCase;
6			use Prophecy\Prophecy\ObjectProphecy;
7			use Yokai\SecurityTokenBundle\Entity\Token;
8			use Yokai\SecurityTokenBundle\Factory\TokenFactoryInterface;
9			use Yokai\SecurityTokenBundle\InformationGuesser\InformationGuesserInterface;
10			use Yokai\SecurityTokenBundle\Manager\TokenManager;
11			use Yokai\SecurityTokenBundle\Manager\UserManagerInterface;
12			use Yokai\SecurityTokenBundle\Repository\TokenRepositoryInterface;
13
14			/**
15			* @author Yann Eugoné <[email protected]>
16			*/
17			class TokenManagerTest extends TestCase
18			{
19			/**
20			* @var \PHPUnit_Framework_MockObject_MockObject
21			*/
22			private $factory;
23
24			/**
25			* @var TokenRepositoryInterface\|ObjectProphecy
26			*/
27			private $repository;
28
29			/**
30			* @var InformationGuesserInterface\|ObjectProphecy
31			*/
32			private $informationGuesser;
33
34			/**
35			* @var UserManagerInterface\|ObjectProphecy
36			*/
37			private $userManager;
38
39			protected function setUp()
40			{
41			$this->factory = $this->createMock(TokenFactoryInterface::class);
42			$this->repository = $this->prophesize(TokenRepositoryInterface::class);
43			$this->informationGuesser = $this->prophesize(InformationGuesserInterface::class);
44			$this->userManager = $this->prophesize(UserManagerInterface::class);
45			}
46
47			protected function tearDown()
48			{
49			unset(
50			$this->factory,
51			$this->repository,
52			$this->informationGuesser,
53			$this->userManager
54			);
55			}
56
57			protected function manager()
58			{
59			return new TokenManager(
60			$this->factory,
61			$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...
62			$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...
63			$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...
64			);
65			}
66
67			/**
68			* @test
69			*/
70			public function it_get_token_from_repository()
71			{
72			$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...
73			->shouldBeCalledTimes(1)
74			->willReturn($expected = $this->prophesize(Token::class)->reveal());
75
76			$token = $this->manager()->get('forgot_password', 'unique-token');
77
78			self::assertSame($expected, $token);
79			}
80
81			/**
82			* @test
83			*/
84			public function it_create_unique_token()
85			{
86			$token1 = new Token('string', 'jdoe','unique-token-1', 'reset-password', '+1 day', []);
87			$token2 = new Token('string', 'jdoe','unique-token-2', 'reset-password', '+1 day', []);
88
89			$this->factory->expects($this->exactly(2))
90			->method('create')
91			->will($this->onConsecutiveCalls($token1, $token2));
92
93			$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...
94			->shouldBeCalledTimes(1)
95			->willReturn(true);
96			$this->repository->exists('unique-token-2', 'forgot_password')
97			->shouldBeCalledTimes(1)
98			->willReturn(false);
99
100			$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...
101			->shouldNotBeCalled();
102			$this->repository->create($token2)
103			->shouldBeCalledTimes(1);
104
105			$token = $this->manager()->create('forgot_password', 'john-doe');
106
107			self::assertSame($token2, $token);
108			}
109
110			/**
111			* @test
112			*/
113			public function it_consume_token()
114			{
115			$token = new Token('string', 'jdoe','unique-token', 'reset-password', '+1 day', []);
116
117			$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...
118			->shouldBeCalledTimes(1)
119			->willReturn(['some', 'precious', 'information']);
120
121			$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...
122			->shouldBeCalledTimes(1);
123
124			$this->manager()->setUsed($token);
125
126			self::assertSame(['some', 'precious', 'information'], $token->getUsedInformation());
127			self::assertInstanceOf(\DateTime::class, $token->getUsedAt());
128			}
129
130			/**
131			* @test
132			*/
133			public function it_extract_user_from_token()
134			{
135			$token = new Token('string', 'jdoe','unique-token', 'reset-password', '+1 day', []);
136
137			$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...
138			->shouldBeCalledTimes(1)
139			->willReturn('john doe');
140
141			$user = $this->manager()->getUser($token);
142
143			self::assertSame('john doe', $user);
144			}
145			}
146

yokai-php / security-token-bundle

Pull Request — master (#7)

TokenManagerTest::setUp() 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