InstallationServiceTest::itCreatesASession() - Code Metrics - verschoof/bunq-api - Measure and Improve Code Quality continuously with Scrutinizer

InstallationServiceTest::itCreatesASession() B
last analyzed 2017-06-08 18:59 UTC

↳ Parent: InstallationServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	44
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	44
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	20
nc	1
nop	0

<?php

namespace Bunq\Tests\Service;

use Bunq\Certificate\CertificateType;
use Bunq\Certificate\DefaultCertificate;
use Bunq\Certificate\Storage\CertificateStorage;
use Bunq\Service\DefaultInstallationService;
use Bunq\Token\DefaultToken;
use GuzzleHttp\ClientInterface;
use PHPUnit\Framework\TestCase;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\Http\Message\ResponseInterface;

final class InstallationServiceTest extends TestCase
{
    /**
     * @var ClientInterface|ObjectProphecy
     */
    private $httpClient;

    /**
     * @var CertificateStorage|ObjectProphecy
     */
    private $certificateStorage;

    /**
     * @var DefaultInstallationService
     */
    private $service;

    public function setUp()
    {
        $this->httpClient         = $this->prophesize(ClientInterface::class);
        $this->certificateStorage = $this->prophesize(CertificateStorage::class);

        $this->service = new DefaultInstallationService(
            $this->httpClient->reveal(),
            $this->certificateStorage->reveal(),
            'apiKey',
            [
                'ip1',
                'ip2',
            ]
        );
    }

    /**
     * @test
     */
    public function itCallsTheInstallationCallWithPublicKey()
    {
        $publicKey = DefaultCertificate::fromString('-----BEGIN PUBLIC KEY-----KEY-----END PUBLIC KEY-----');

        $this->certificateStorage->load(CertificateType::PUBLIC_KEY())->willReturn($publicKey);
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.
}

        $postOptions = [
            'json' => [
                'client_public_key' => $publicKey->toString(),
            ],
        ];

        $expectedToken = 'installation-token';
        $expectedKey   = '-----BEGIN PUBLIC KEY-----NEW-KEY-----END PUBLIC KEY-----';

        /** @var ResponseInterface|ObjectProphecy $response */
        $response = $this->prophesize(ResponseInterface::class);
        $response->getBody()->willReturn(
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.
}
            \json_encode(
                [
                    'Response' => [
                        [
                            'Id' => [
                                'id' => 1,
                            ],
                        ],
                        [
                            'Token' => [
                                'token' => $expectedToken,
                            ],
                        ],
                        [
                            'ServerPublicKey' => [
                                'server_public_key' => $expectedKey,
                            ],
                        ],
                    ],
                ]
            )
        );

        $this->httpClient->request('POST', '/v1/installation', $postOptions)->willReturn(
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.
}
            $response->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.
}
        );

        $result = $this->service->install();

        $this->assertEquals(
            [
                'token'      => $expectedToken,
                'public_key' => $expectedKey,
            ],
            $result
        );
    }

    /**
     * @test
     */
    public function itRegistersADevice()
    {
        $installationToken = new DefaultToken('installation-token');

        $postOptions = [
            'headers' => [
                'X-Bunq-Client-Authentication' => 'installation-token',
            ],
            'json' => [
                'description'   => 'Bunq PHP API Client',
                'secret'        => 'apiKey',
                'permitted_ips' => ['ip1', 'ip2'],
            ],
        ];

        $this->httpClient->request('POST', '/v1/device-server', $postOptions)->shouldBeCalled();
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->service->registerDevice($installationToken);
    }

    /**
     * @test
     */
    public function itCreatesASession()
    {
        $installationToken = new DefaultToken('installation-token');

        $postOptions = [
            'headers' => [
                'X-Bunq-Client-Authentication' => 'installation-token',
            ],
            'json'    => [
                'secret' => 'apiKey',
            ]
        ];

        $expectedToken = 'session-token';

        /** @var ResponseInterface|ObjectProphecy $response */
        $response = $this->prophesize(ResponseInterface::class);
        $response->getBody()->willReturn(
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.
}
            \json_encode(
                [
                    'Response' => [
                        [
                            'Id' => [
                                'id' => 1,
                            ],
                        ],
                        [
                            'Token' => [
                                'token' => $expectedToken,
                            ],
                        ]
                    ],
                ]
            )
        );

        $this->httpClient->request('POST', '/v1/session-server', $postOptions)->willReturn(
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.
}
            $response->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.
}
        );

        $result = $this->service->createSession($installationToken);

        $this->assertEquals($expectedToken, $result);
    }
}



1			<?php
2
3			namespace Bunq\Tests\Service;
4
5			use Bunq\Certificate\CertificateType;
6			use Bunq\Certificate\DefaultCertificate;
7			use Bunq\Certificate\Storage\CertificateStorage;
8			use Bunq\Service\DefaultInstallationService;
9			use Bunq\Token\DefaultToken;
10			use GuzzleHttp\ClientInterface;
11			use PHPUnit\Framework\TestCase;
12			use Prophecy\Prophecy\ObjectProphecy;
13			use Psr\Http\Message\ResponseInterface;
14
15			final class InstallationServiceTest extends TestCase
16			{
17			/**
18			* @var ClientInterface\|ObjectProphecy
19			*/
20			private $httpClient;
21
22			/**
23			* @var CertificateStorage\|ObjectProphecy
24			*/
25			private $certificateStorage;
26
27			/**
28			* @var DefaultInstallationService
29			*/
30			private $service;
31
32			public function setUp()
33			{
34			$this->httpClient = $this->prophesize(ClientInterface::class);
35			$this->certificateStorage = $this->prophesize(CertificateStorage::class);
36
37			$this->service = new DefaultInstallationService(
38			$this->httpClient->reveal(),
39			$this->certificateStorage->reveal(),
40			'apiKey',
41			[
42			'ip1',
43			'ip2',
44			]
45			);
46			}
47
48			/**
49			* @test
50			*/
51			public function itCallsTheInstallationCallWithPublicKey()
52			{
53			$publicKey = DefaultCertificate::fromString('-----BEGIN PUBLIC KEY-----KEY-----END PUBLIC KEY-----');
54
55			$this->certificateStorage->load(CertificateType::PUBLIC_KEY())->willReturn($publicKey);
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `load` does only exist in `Bunq\Certificate\Storage\CertificateStorage`, 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...
56
57			$postOptions = [
58			'json' => [
59			'client_public_key' => $publicKey->toString(),
60			],
61			];
62
63			$expectedToken = 'installation-token';
64			$expectedKey = '-----BEGIN PUBLIC KEY-----NEW-KEY-----END PUBLIC KEY-----';
65
66			/** @var ResponseInterface\|ObjectProphecy $response */
67			$response = $this->prophesize(ResponseInterface::class);
68			$response->getBody()->willReturn(
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `getBody` does only exist in `Psr\Http\Message\ResponseInterface`, 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...
69			\json_encode(
70			[
71			'Response' => [
72			[
73			'Id' => [
74			'id' => 1,
75			],
76			],
77			[
78			'Token' => [
79			'token' => $expectedToken,
80			],
81			],
82			[
83			'ServerPublicKey' => [
84			'server_public_key' => $expectedKey,
85			],
86			],
87			],
88			]
89			)
90			);
91
92			$this->httpClient->request('POST', '/v1/installation', $postOptions)->willReturn(
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `request` does only exist in `GuzzleHttp\ClientInterface`, 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			$response->reveal()
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `reveal` does only exist in `Prophecy\Prophecy\ObjectProphecy`, but not in `Psr\Http\Message\ResponseInterface`. 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			);
95
96			$result = $this->service->install();
97
98			$this->assertEquals(
99			[
100			'token' => $expectedToken,
101			'public_key' => $expectedKey,
102			],
103			$result
104			);
105			}
106
107			/**
108			* @test
109			*/
110			public function itRegistersADevice()
111			{
112			$installationToken = new DefaultToken('installation-token');
113
114			$postOptions = [
115			'headers' => [
116			'X-Bunq-Client-Authentication' => 'installation-token',
117			],
118			'json' => [
119			'description' => 'Bunq PHP API Client',
120			'secret' => 'apiKey',
121			'permitted_ips' => ['ip1', 'ip2'],
122			],
123			];
124
125			$this->httpClient->request('POST', '/v1/device-server', $postOptions)->shouldBeCalled();
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `request` does only exist in `GuzzleHttp\ClientInterface`, 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...
126
127			$this->service->registerDevice($installationToken);
128			}
129
130			/**
131			* @test
132			*/
133			public function itCreatesASession()
134			{
135			$installationToken = new DefaultToken('installation-token');
136
137			$postOptions = [
138			'headers' => [
139			'X-Bunq-Client-Authentication' => 'installation-token',
140			],
141			'json' => [
142			'secret' => 'apiKey',
143			]
144			];
145
146			$expectedToken = 'session-token';
147
148			/** @var ResponseInterface\|ObjectProphecy $response */
149			$response = $this->prophesize(ResponseInterface::class);
150			$response->getBody()->willReturn(
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `getBody` does only exist in `Psr\Http\Message\ResponseInterface`, 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...
151			\json_encode(
152			[
153			'Response' => [
154			[
155			'Id' => [
156			'id' => 1,
157			],
158			],
159			[
160			'Token' => [
161			'token' => $expectedToken,
162			],
163			]
164			],
165			]
166			)
167			);
168
169			$this->httpClient->request('POST', '/v1/session-server', $postOptions)->willReturn(
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `request` does only exist in `GuzzleHttp\ClientInterface`, 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...
170			$response->reveal()
			0 ignored issues – show Bug introduced 2017-05-20 13:58 UTC by Report Bug Copy Issue Report The method `reveal` does only exist in `Prophecy\Prophecy\ObjectProphecy`, but not in `Psr\Http\Message\ResponseInterface`. 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...
171			);
172
173			$result = $this->service->createSession($installationToken);
174
175			$this->assertEquals($expectedToken, $result);
176			}
177			}
178
179

verschoof / bunq-api

InstallationServiceTest::itCreatesASession() B last analyzed 2017-06-08 18:59 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

InstallationServiceTest::itCreatesASession() B
last analyzed 2017-06-08 18:59 UTC