AbstractMethodTest::testSetResponseException() - Code Metrics - Inspection of "Fix duplicated orders" - pagantis/prestashop - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#59)

by Raúl

created 2020-01-07 10:20 UTC

AbstractMethodTest::testSetResponseException() A

↳ Parent: AbstractMethodTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	23
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	16
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	23
rs	9.7333

<?php

namespace Test\Pagantis\OrdersApiClient\Method;

use Httpful\Request;
use Pagantis\OrdersApiClient\Exception\HttpException;
use Pagantis\OrdersApiClient\Method\AbstractMethod;
use Pagantis\OrdersApiClient\Model\ApiConfiguration;
use Test\Pagantis\OrdersApiClient\AbstractTest;

/**
 * Class AbstractMethodTest
 *
 * @package Test\Pagantis\OrdersApiClient\Method;
 */
class AbstractMethodTest extends AbstractTest
{
    /**
     * Has Slash
     */
    public function testHasSlashConstant()
    {
        $constant = AbstractMethod::SLASH;
        $this->assertEquals('/', $constant);
    }

    /**
     * Test Constructor
     *
     * @throws \ReflectionException
     */
    public function testConstructor()
    {
        $apiConfiguration = new ApiConfiguration();
        $abstractMethod = $this->getMock(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            array('call'),
            array($apiConfiguration)
        );

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $property = $reflectedClass->getProperty('apiConfiguration');
        $property->setAccessible(true);
        $this->assertSame($apiConfiguration, $property->getValue($abstractMethod));
    }

    /**
     * Test get Request
     *
     * @throws \ReflectionException
     */
    public function testGetRequest()
    {
        $headers = array('key' => 'value');
        $publicKey = 'publicKey';
        $privateKey = 'privateKey';

        $apiConfiguration = new ApiConfiguration();
        $apiConfiguration
            ->setHeaders($headers)
            ->setPrivateKey($privateKey)
            ->setPublicKey($publicKey)
        ;
        $abstractMethod = $this->getMock(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            array('call'),
            array($apiConfiguration)
        );

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $method = $reflectedClass->getMethod('getRequest');
        $method->setAccessible(true);
        /** @var Request $request */
        $request = $method->invoke($abstractMethod);
        $this->assertInstanceOf('Httpful\Request', $request);

        $this->assertSame($headers, $request->headers);
        $this->assertSame($publicKey, $request->username);
        $this->assertSame($privateKey, $request->password);
    }

    /**
     * testGetResponse
     *
     * @throws \ReflectionException
     */
    public function testGetResponse()
    {
        $apiConfiguration = new ApiConfiguration();
        $abstractMethod = $this->getMock(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            array('call'),
            array($apiConfiguration)
        );

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $method = $reflectedClass->getMethod('getResponse');
        $method->setAccessible(true);
        $this->assertFalse($method->invoke($abstractMethod));

        $responseMock = $this->getMockBuilder('Httpful\Response')->disableOriginalConstructor()->getMock();
        $property = $reflectedClass->getProperty('response');
        $property->setAccessible(true);
        $property->setValue($abstractMethod, $responseMock);
        $this->assertInstanceOf('Httpful\Response', $method->invoke($abstractMethod));
    }

    /**
     * testGetResponseAsJson
     *
     * @throws \ReflectionException
     */
    public function testGetResponseAsJson()
    {
        $apiConfiguration = new ApiConfiguration();
        $abstractMethod = $this->getMock(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            array('call'),
            array($apiConfiguration)
        );

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $method = $reflectedClass->getMethod('getResponseAsJson');
        $method->setAccessible(true);
        $this->assertFalse($method->invoke($abstractMethod));

        $json = 'body';
        $responseMock = $this->getMockBuilder('Httpful\Response')->disableOriginalConstructor()->getMock();
        $responseMockReflect = new \ReflectionClass('Httpful\Response');
        $property = $responseMockReflect->getProperty('raw_body');
        $property->setAccessible(true);
        $property->setValue($responseMock, $json);

        $property = $reflectedClass->getProperty('response');
        $property->setAccessible(true);
        $property->setValue($abstractMethod, $responseMock);
        $this->assertSame($json, $method->invoke($abstractMethod));
    }

    /**
     * Test Add get parameters work correctly
     *
     * @throws \ReflectionException
     */
    public function testAddGetParameters()
    {
        $apiConfiguration = new ApiConfiguration();
        $abstractMethod = $this->getMock(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            array('call'),
            array($apiConfiguration)
        );

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $method = $reflectedClass->getMethod('addGetParameters');
        $method->setAccessible(true);
        $this->assertEquals('', $method->invoke($abstractMethod, array()));
        $this->assertEquals('?id=123', $method->invoke($abstractMethod, array('id' => 123)));
    }

    /**
     * Test Parse HTTP Exceptions
     *
     * @throws \ReflectionException
     */
    public function testParseHttpException()
    {
        $apiConfiguration = new ApiConfiguration();
        $abstractMethod = $this->getMock(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            array('call'),
            array($apiConfiguration)
        );

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $method = $reflectedClass->getMethod('parseHttpException');
        $method->setAccessible(true);
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_BAD_REQUEST);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_UNAUTHORIZED);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_FORBIDDEN);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_NOT_FOUND);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_METHOD_NOT_ALLOWED);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_UNPROCESSABLE_ENTITY);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_INTERNAL_SERVER_ERROR);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
        try {
            $method->invoke($abstractMethod, HttpException::HTTP_SERVICE_UNAVAILABLE);
        } catch (\Exception $exception) {
            $this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
        }
    }

    /**
     * testSetResponse
     *
     * @expectedException Pagantis\OrdersApiClient\Exception\HttpException
     *
     * @throws \ReflectionException
     */
    public function testSetResponseException()
    {
        $responseMock = $this
            ->getMockBuilder('Httpful\Response')
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $abstractMethod = $this
            ->getMockBuilder('Pagantis\OrdersApiClient\Method\AbstractMethod')
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $method = $reflectedClass->getMethod('setResponse');
        $method->setAccessible(true);

        $responseMock->code = HttpException::HTTP_INTERNAL_SERVER_ERROR;

        $responseMock->method('hasErrors')->willReturn(true);
        $this->assertInstanceOf(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            $method->invoke($abstractMethod, $responseMock)
        );
    }

    /**
     * testSetResponse
     *
     * @throws \ReflectionException
     */
    public function testSetResponse()
    {
        $responseMock = $this
            ->getMockBuilder('Httpful\Response')
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $abstractMethod = $this
            ->getMockBuilder('Pagantis\OrdersApiClient\Method\AbstractMethod')
            ->disableOriginalConstructor()
            ->getMock()
        ;

        $reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
        $method = $reflectedClass->getMethod('setResponse');
        $method->setAccessible(true);

        $responseMock->method('hasErrors')->willReturn(false);
        $this->assertInstanceOf(
            'Pagantis\OrdersApiClient\Method\AbstractMethod',
            $method->invoke($abstractMethod, $responseMock)
        );
    }
}


1			<?php
2
3			namespace Test\Pagantis\OrdersApiClient\Method;
4
5			use Httpful\Request;
6			use Pagantis\OrdersApiClient\Exception\HttpException;
7			use Pagantis\OrdersApiClient\Method\AbstractMethod;
8			use Pagantis\OrdersApiClient\Model\ApiConfiguration;
9			use Test\Pagantis\OrdersApiClient\AbstractTest;
10
11			/**
12			* Class AbstractMethodTest
13			*
14			* @package Test\Pagantis\OrdersApiClient\Method;
15			*/
16			class AbstractMethodTest extends AbstractTest
17			{
18			/**
19			* Has Slash
20			*/
21			public function testHasSlashConstant()
22			{
23			$constant = AbstractMethod::SLASH;
24			$this->assertEquals('/', $constant);
25			}
26
27			/**
28			* Test Constructor
29			*
30			* @throws \ReflectionException
31			*/
32			public function testConstructor()
33			{
34			$apiConfiguration = new ApiConfiguration();
35			$abstractMethod = $this->getMock(
36			'Pagantis\OrdersApiClient\Method\AbstractMethod',
37			array('call'),
38			array($apiConfiguration)
39			);
40
41			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
42			$property = $reflectedClass->getProperty('apiConfiguration');
43			$property->setAccessible(true);
44			$this->assertSame($apiConfiguration, $property->getValue($abstractMethod));
45			}
46
47			/**
48			* Test get Request
49			*
50			* @throws \ReflectionException
51			*/
52			public function testGetRequest()
53			{
54			$headers = array('key' => 'value');
55			$publicKey = 'publicKey';
56			$privateKey = 'privateKey';
57
58			$apiConfiguration = new ApiConfiguration();
59			$apiConfiguration
60			->setHeaders($headers)
61			->setPrivateKey($privateKey)
62			->setPublicKey($publicKey)
63			;
64			$abstractMethod = $this->getMock(
65			'Pagantis\OrdersApiClient\Method\AbstractMethod',
66			array('call'),
67			array($apiConfiguration)
68			);
69
70			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
71			$method = $reflectedClass->getMethod('getRequest');
72			$method->setAccessible(true);
73			/** @var Request $request */
74			$request = $method->invoke($abstractMethod);
75			$this->assertInstanceOf('Httpful\Request', $request);
76
77			$this->assertSame($headers, $request->headers);
78			$this->assertSame($publicKey, $request->username);
79			$this->assertSame($privateKey, $request->password);
80			}
81
82			/**
83			* testGetResponse
84			*
85			* @throws \ReflectionException
86			*/
87			public function testGetResponse()
88			{
89			$apiConfiguration = new ApiConfiguration();
90			$abstractMethod = $this->getMock(
91			'Pagantis\OrdersApiClient\Method\AbstractMethod',
92			array('call'),
93			array($apiConfiguration)
94			);
95
96			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
97			$method = $reflectedClass->getMethod('getResponse');
98			$method->setAccessible(true);
99			$this->assertFalse($method->invoke($abstractMethod));
100
101			$responseMock = $this->getMockBuilder('Httpful\Response')->disableOriginalConstructor()->getMock();
102			$property = $reflectedClass->getProperty('response');
103			$property->setAccessible(true);
104			$property->setValue($abstractMethod, $responseMock);
105			$this->assertInstanceOf('Httpful\Response', $method->invoke($abstractMethod));
106			}
107
108			/**
109			* testGetResponseAsJson
110			*
111			* @throws \ReflectionException
112			*/
113			public function testGetResponseAsJson()
114			{
115			$apiConfiguration = new ApiConfiguration();
116			$abstractMethod = $this->getMock(
117			'Pagantis\OrdersApiClient\Method\AbstractMethod',
118			array('call'),
119			array($apiConfiguration)
120			);
121
122			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
123			$method = $reflectedClass->getMethod('getResponseAsJson');
124			$method->setAccessible(true);
125			$this->assertFalse($method->invoke($abstractMethod));
126
127			$json = 'body';
128			$responseMock = $this->getMockBuilder('Httpful\Response')->disableOriginalConstructor()->getMock();
129			$responseMockReflect = new \ReflectionClass('Httpful\Response');
130			$property = $responseMockReflect->getProperty('raw_body');
131			$property->setAccessible(true);
132			$property->setValue($responseMock, $json);
133
134			$property = $reflectedClass->getProperty('response');
135			$property->setAccessible(true);
136			$property->setValue($abstractMethod, $responseMock);
137			$this->assertSame($json, $method->invoke($abstractMethod));
138			}
139
140			/**
141			* Test Add get parameters work correctly
142			*
143			* @throws \ReflectionException
144			*/
145			public function testAddGetParameters()
146			{
147			$apiConfiguration = new ApiConfiguration();
148			$abstractMethod = $this->getMock(
149			'Pagantis\OrdersApiClient\Method\AbstractMethod',
150			array('call'),
151			array($apiConfiguration)
152			);
153
154			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
155			$method = $reflectedClass->getMethod('addGetParameters');
156			$method->setAccessible(true);
157			$this->assertEquals('', $method->invoke($abstractMethod, array()));
158			$this->assertEquals('?id=123', $method->invoke($abstractMethod, array('id' => 123)));
159			}
160
161			/**
162			* Test Parse HTTP Exceptions
163			*
164			* @throws \ReflectionException
165			*/
166			public function testParseHttpException()
167			{
168			$apiConfiguration = new ApiConfiguration();
169			$abstractMethod = $this->getMock(
170			'Pagantis\OrdersApiClient\Method\AbstractMethod',
171			array('call'),
172			array($apiConfiguration)
173			);
174
175			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
176			$method = $reflectedClass->getMethod('parseHttpException');
177			$method->setAccessible(true);
178			try {
179			$method->invoke($abstractMethod, HttpException::HTTP_BAD_REQUEST);
180			} catch (\Exception $exception) {
181			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
182			}
183			try {
184			$method->invoke($abstractMethod, HttpException::HTTP_UNAUTHORIZED);
185			} catch (\Exception $exception) {
186			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
187			}
188			try {
189			$method->invoke($abstractMethod, HttpException::HTTP_FORBIDDEN);
190			} catch (\Exception $exception) {
191			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
192			}
193			try {
194			$method->invoke($abstractMethod, HttpException::HTTP_NOT_FOUND);
195			} catch (\Exception $exception) {
196			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
197			}
198			try {
199			$method->invoke($abstractMethod, HttpException::HTTP_METHOD_NOT_ALLOWED);
200			} catch (\Exception $exception) {
201			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
202			}
203			try {
204			$method->invoke($abstractMethod, HttpException::HTTP_UNPROCESSABLE_ENTITY);
205			} catch (\Exception $exception) {
206			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
207			}
208			try {
209			$method->invoke($abstractMethod, HttpException::HTTP_INTERNAL_SERVER_ERROR);
210			} catch (\Exception $exception) {
211			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
212			}
213			try {
214			$method->invoke($abstractMethod, HttpException::HTTP_SERVICE_UNAVAILABLE);
215			} catch (\Exception $exception) {
216			$this->assertInstanceOf('Pagantis\OrdersApiClient\Exception\HttpException', $exception);
217			}
218			}
219
220			/**
221			* testSetResponse
222			*
223			* @expectedException Pagantis\OrdersApiClient\Exception\HttpException
224			*
225			* @throws \ReflectionException
226			*/
227			public function testSetResponseException()
228			{
229			$responseMock = $this
230			->getMockBuilder('Httpful\Response')
231			->disableOriginalConstructor()
232			->getMock()
233			;
234
235			$abstractMethod = $this
236			->getMockBuilder('Pagantis\OrdersApiClient\Method\AbstractMethod')
237			->disableOriginalConstructor()
238			->getMock()
239			;
240
241			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
242			$method = $reflectedClass->getMethod('setResponse');
243			$method->setAccessible(true);
244
245			$responseMock->code = HttpException::HTTP_INTERNAL_SERVER_ERROR;
			0 ignored issues – show Bug introduced 2020-01-07 10:18 UTC by Report Bug Copy Issue Report Accessing `code` on the interface `PHPUnit_Framework_MockObject_MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
246			$responseMock->method('hasErrors')->willReturn(true);
247			$this->assertInstanceOf(
248			'Pagantis\OrdersApiClient\Method\AbstractMethod',
249			$method->invoke($abstractMethod, $responseMock)
250			);
251			}
252
253			/**
254			* testSetResponse
255			*
256			* @throws \ReflectionException
257			*/
258			public function testSetResponse()
259			{
260			$responseMock = $this
261			->getMockBuilder('Httpful\Response')
262			->disableOriginalConstructor()
263			->getMock()
264			;
265
266			$abstractMethod = $this
267			->getMockBuilder('Pagantis\OrdersApiClient\Method\AbstractMethod')
268			->disableOriginalConstructor()
269			->getMock()
270			;
271
272			$reflectedClass = new \ReflectionClass('Pagantis\OrdersApiClient\Method\AbstractMethod');
273			$method = $reflectedClass->getMethod('setResponse');
274			$method->setAccessible(true);
275
276			$responseMock->method('hasErrors')->willReturn(false);
277			$this->assertInstanceOf(
278			'Pagantis\OrdersApiClient\Method\AbstractMethod',
279			$method->invoke($abstractMethod, $responseMock)
280			);
281			}
282			}
283

pagantis / prestashop

Pull Request — master (#59)

AbstractMethodTest::testSetResponseException() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like