ResponseTransformerTest::testTransformLateWrapperPostMessage() - Code Metrics - Inspection of "Update readme, fix scrutinizer path" - mediamonks/php-rest-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8796f9...232efd )

unknown

created 2017-01-30 11:48 UTC

ResponseTransformerTest::testTransformLateWrapperPostMessage() B

↳ Parent: Project

Complexity

Conditions	2
Paths	3

Size

Total Lines	27
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	18
nc	3
nop	0
dl	0
loc	27
rs	8.8571
c	0
b	0
f	0

<?php

namespace tests\MediaMonks\RestApi\Response;

use MediaMonks\RestApi\Model\ResponseModel;
use MediaMonks\RestApi\Request\Format;
use MediaMonks\RestApi\Response\ResponseTransformer;
use \Mockery as m;
use Symfony\Component\HttpFoundation\Response;

class ResponseTransformerTest extends \PHPUnit_Framework_TestCase
{
    private $responseModelFactory;

    protected function getSubject($options = [])
    {
        $serializer = m::mock('MediaMonks\RestApi\Serializer\SerializerInterface');
        $serializer->shouldReceive('serialize');

        $responseModel = new ResponseModel();

        $responseModelFactory = m::mock('MediaMonks\RestApi\Model\ResponseModelFactory');
        $responseModelFactory->shouldReceive('createFromContent')->andReturn($responseModel);

        $this->responseModelFactory = $responseModelFactory;

        return new ResponseTransformer($serializer, $responseModelFactory, $options);
    }

    public function testConstructSetsOptions()
    {
        $origin  = 'postmsgorigin';
        $subject = $this->getSubject(['post_message_origin' => $origin]);

        $this->assertEquals($origin, $subject->getPostMessageOrigin());
    }

    public function testSetOptions()
    {
        $subject = $this->getSubject();
        $origin  = 'postmsgorigin';

        $subject->setOptions(['post_message_origin' => $origin]);

        $this->assertEquals($origin, $subject->getPostMessageOrigin());
    }

    public function testSetOptionsWithoutPostMessageOrigin()
    {
        $subject = $this->getSubject();
        $origin  = 'postmsgorigin';

        $subject->setOptions(['someotherkey' => $origin]);

        $this->assertNull($subject->getPostMessageOrigin());
    }

    public function testSetPostMessageOrigin()
    {
        $subject = $this->getSubject();
        $origin  = 'postmsgorigin';

        $subject->setPostMessageOrigin($origin);

        $this->assertEquals($origin, $subject->getPostMessageOrigin());
    }

    public function testTransformLateFalsePreconditions()
    {
        $subject = $this->getSubject();

        $request = m::mock('Symfony\Component\HttpFoundation\Request');
        $request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_XML);;

        $response = m::mock('Symfony\Component\HttpFoundation\Response');
        $response->shouldReceive('setCallback');

        $subject->transformLate($request, $response);

        try {
            $response->shouldNotHaveReceived('setCallback');
            $response->shouldNotHaveReceived('setContent');
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false);
        }
    }

    public function testTransformLateWrapperPostMessage()
    {
        $subject = $this->getSubject();

        $request = m::mock('Symfony\Component\HttpFoundation\Request');
        $request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);

        $request->query = m::mock('\Symfony\Component\HttpFoundation\ParameterBag');
        $request->query->shouldReceive('has')->andReturn(true);
        $request->query->shouldReceive('get')->andReturn(ResponseTransformer::WRAPPER_POST_MESSAGE);

        $response = m::mock('MediaMonks\RestApi\Response\JsonResponse');
        $response->shouldReceive('setContent')->andReturnSelf();
        $response->shouldReceive('getContent')->andReturn('foo');

        $response->headers = m::mock('\Symfony\Component\HttpFoundation\ResponseHeaderBag');
        $response->headers->shouldReceive('set');

        $subject->transformLate($request, $response);

        try {
            $response->shouldHaveReceived('setContent')->between(1, 1);
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false);
        }
    }

    public function testTransformLateWrapperCallback()
    {
        $subject = $this->getSubject();

        $request = m::mock('Symfony\Component\HttpFoundation\Request');
        $request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);
        $request->query = m::mock('\Symfony\Component\HttpFoundation\ParameterBag');
        $request->query->shouldReceive('has')->andReturn(true);
        $request->query->shouldReceive('get');

        $response = m::mock('MediaMonks\RestApi\Response\JsonResponse');
        $response->shouldReceive('setCallback');

        $subject->transformLate($request, $response);

        try {
            $response->shouldHaveReceived('setCallback')->between(1, 1);
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false);
        }
    }

    public function testTransformEarlyWResponseModelHappyPath()
    {
        // Get SUT
        $subject = $this->getSubject();

        // Prepare/mock pre-conditions
        $request = m::mock('Symfony\Component\HttpFoundation\Request');
        $request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);

        $request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
        $request->headers->shouldReceive('has')->andReturn(false);

        $request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
        $request->query->shouldReceive('has')->andReturn(false);

        $responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
        $responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
        $responseModel->shouldReceive('setReturnStatusCode');
        $responseModel->shouldReceive('setReturnStackTrace');

        $response = m::mock('Symfony\Component\HttpFoundation\Response');
        $response->shouldReceive('getContent')->andReturn($responseModel);
        $response->shouldReceive('setStatusCode');

        // Perform operation
        $actualResponse = $subject->transformEarly($request, $response);

        // Verify post-conditions
        $this->assertNoException(function () use ($response) {
            $response->shouldHaveReceived('setStatusCode')->with(Response::HTTP_CONFLICT);
        });
        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $actualResponse);
    }

    public function testTransformEarlyForceHttpOk()
    {
        // Get SUT
        $subject = $this->getSubject();

        // Prepare/mock pre-conditions
        $request = m::mock('Symfony\Component\HttpFoundation\Request');
        $request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);

        $request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
        $request->headers->shouldReceive('has')->andReturn(true);

        $request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
        $request->query->shouldReceive('has')->andReturn(false);

        $responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
        $responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
        $responseModel->shouldReceive('setReturnStatusCode');
        $responseModel->shouldReceive('setReturnStackTrace');
        $responseModel->shouldReceive('toArray');

        $response = m::mock('Symfony\Component\HttpFoundation\Response');
        $response->shouldReceive('getContent')->andReturn($responseModel);
        $response->shouldReceive('setStatusCode');
        $response->shouldReceive('getStatusCode')->andReturn(200);

        $response->headers = m::mock('Symfony\Component\HttpFoundation\ResponseHeaderBag');
        $response->headers->shouldReceive('set');

        // Perform operation
        $subject->transformEarly($request, $response);

        // Verify post-conditions
        $this->assertNoException(function () use ($response) {
            $response->shouldHaveReceived('setStatusCode')->with(Response::HTTP_OK);
        });
    }

    public function testTransformEarlySerializeXml()
    {
        // Get SUT
        $subject = $this->getSubject();

        // Prepare/mock pre-conditions
        $request = m::mock('Symfony\Component\HttpFoundation\Request');
        $request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_XML);

        $request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
        $request->headers->shouldReceive('has')->andReturn(true);

        $request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
        $request->query->shouldReceive('has')->andReturn(false);

        $responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
        $responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
        $responseModel->shouldReceive('setReturnStatusCode');
        $responseModel->shouldReceive('setReturnStackTrace');
        $responseModel->shouldReceive('toArray');

        $response = m::mock('Symfony\Component\HttpFoundation\Response');
        $response->shouldReceive('getContent')->andReturn($responseModel);
        $response->shouldReceive('setStatusCode');
        $response->shouldReceive('getStatusCode')->andReturn(200);
        $response->shouldReceive('setContent');

        $response->headers = m::mock('Symfony\Component\HttpFoundation\ResponseHeaderBag');
        $response->headers->shouldReceive('set');

        // Perform operation
        $subject->transformEarly($request, $response);

        // Verify post-conditions
        $this->assertNoException(function () use ($response) {
            $response->shouldHaveReceived('setStatusCode')->with(Response::HTTP_OK);
            $response->shouldHaveReceived('setContent');
        });
    }

    public function testTransformEarlyWOResponseModel()
    {
        // Get SUT
        $subject = $this->getSubject();

        // Prepare/mock pre-conditions
        $content = 'some content';

        $request = m::mock('Symfony\Component\HttpFoundation\Request');
        $request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_XML);

        $request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
        $request->headers->shouldReceive('has')->andReturn(true);

        $request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
        $request->query->shouldReceive('has')->andReturn(false);

        $response = m::mock('Symfony\Component\HttpFoundation\Response');
        $response->shouldReceive('getContent')->andReturn($content);
        $response->shouldReceive('setStatusCode');
        $response->shouldReceive('getStatusCode')->andReturn(200);
        $response->shouldReceive('setContent');

        $response->headers = m::mock('Symfony\Component\HttpFoundation\ResponseHeaderBag');
        $response->headers->shouldReceive('set');

        $responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
        $responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
        $responseModel->shouldReceive('setReturnStatusCode');
        $responseModel->shouldReceive('setReturnStackTrace');
        $responseModel->shouldReceive('toArray');

        // Perform operation
        $subject->transformEarly($request, $response);

        $factory = $this->responseModelFactory;

        // Verify post-conditions
        $this->assertNoException(function () use ($factory, $content) {
            $factory->shouldHaveReceived('createFromContent');
        });
    }

    protected function assertNoException($callback)
    {
        try {
            $callback();
            $this->assertTrue(true);
        } catch (\Exception $e) {
            $this->assertTrue(false, 'Exception thrown when none was expected. Exception message: ' . $e->getMessage());
        }
    }
}


1			<?php
2
3			namespace tests\MediaMonks\RestApi\Response;
4
5			use MediaMonks\RestApi\Model\ResponseModel;
6			use MediaMonks\RestApi\Request\Format;
7			use MediaMonks\RestApi\Response\ResponseTransformer;
8			use \Mockery as m;
9			use Symfony\Component\HttpFoundation\Response;
10
11			class ResponseTransformerTest extends \PHPUnit_Framework_TestCase
12			{
13			private $responseModelFactory;
14
15			protected function getSubject($options = [])
16			{
17			$serializer = m::mock('MediaMonks\RestApi\Serializer\SerializerInterface');
18			$serializer->shouldReceive('serialize');
19
20			$responseModel = new ResponseModel();
21
22			$responseModelFactory = m::mock('MediaMonks\RestApi\Model\ResponseModelFactory');
23			$responseModelFactory->shouldReceive('createFromContent')->andReturn($responseModel);
24
25			$this->responseModelFactory = $responseModelFactory;
26
27			return new ResponseTransformer($serializer, $responseModelFactory, $options);
28			}
29
30			public function testConstructSetsOptions()
31			{
32			$origin = 'postmsgorigin';
33			$subject = $this->getSubject(['post_message_origin' => $origin]);
34
35			$this->assertEquals($origin, $subject->getPostMessageOrigin());
36			}
37
38			public function testSetOptions()
39			{
40			$subject = $this->getSubject();
41			$origin = 'postmsgorigin';
42
43			$subject->setOptions(['post_message_origin' => $origin]);
44
45			$this->assertEquals($origin, $subject->getPostMessageOrigin());
46			}
47
48			public function testSetOptionsWithoutPostMessageOrigin()
49			{
50			$subject = $this->getSubject();
51			$origin = 'postmsgorigin';
52
53			$subject->setOptions(['someotherkey' => $origin]);
54
55			$this->assertNull($subject->getPostMessageOrigin());
56			}
57
58			public function testSetPostMessageOrigin()
59			{
60			$subject = $this->getSubject();
61			$origin = 'postmsgorigin';
62
63			$subject->setPostMessageOrigin($origin);
64
65			$this->assertEquals($origin, $subject->getPostMessageOrigin());
66			}
67
68			public function testTransformLateFalsePreconditions()
69			{
70			$subject = $this->getSubject();
71
72			$request = m::mock('Symfony\Component\HttpFoundation\Request');
73			$request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_XML);;
74
75			$response = m::mock('Symfony\Component\HttpFoundation\Response');
76			$response->shouldReceive('setCallback');
77
78			$subject->transformLate($request, $response);
79
80			try {
81			$response->shouldNotHaveReceived('setCallback');
82			$response->shouldNotHaveReceived('setContent');
83			$this->assertTrue(true);
84			} catch (\Exception $e) {
85			$this->assertTrue(false);
86			}
87			}
88
89			public function testTransformLateWrapperPostMessage()
90			{
91			$subject = $this->getSubject();
92
93			$request = m::mock('Symfony\Component\HttpFoundation\Request');
94			$request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);
95
96			$request->query = m::mock('\Symfony\Component\HttpFoundation\ParameterBag');
97			$request->query->shouldReceive('has')->andReturn(true);
98			$request->query->shouldReceive('get')->andReturn(ResponseTransformer::WRAPPER_POST_MESSAGE);
99
100			$response = m::mock('MediaMonks\RestApi\Response\JsonResponse');
101			$response->shouldReceive('setContent')->andReturnSelf();
102			$response->shouldReceive('getContent')->andReturn('foo');
103
104			$response->headers = m::mock('\Symfony\Component\HttpFoundation\ResponseHeaderBag');
105			$response->headers->shouldReceive('set');
106
107			$subject->transformLate($request, $response);
108
109			try {
110			$response->shouldHaveReceived('setContent')->between(1, 1);
111			$this->assertTrue(true);
112			} catch (\Exception $e) {
113			$this->assertTrue(false);
114			}
115			}
116
117			public function testTransformLateWrapperCallback()
118			{
119			$subject = $this->getSubject();
120
121			$request = m::mock('Symfony\Component\HttpFoundation\Request');
122			$request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);
123			$request->query = m::mock('\Symfony\Component\HttpFoundation\ParameterBag');
124			$request->query->shouldReceive('has')->andReturn(true);
125			$request->query->shouldReceive('get');
126
127			$response = m::mock('MediaMonks\RestApi\Response\JsonResponse');
128			$response->shouldReceive('setCallback');
129
130			$subject->transformLate($request, $response);
131
132			try {
133			$response->shouldHaveReceived('setCallback')->between(1, 1);
134			$this->assertTrue(true);
135			} catch (\Exception $e) {
136			$this->assertTrue(false);
137			}
138			}
139
140			public function testTransformEarlyWResponseModelHappyPath()
141			{
142			// Get SUT
143			$subject = $this->getSubject();
144
145			// Prepare/mock pre-conditions
146			$request = m::mock('Symfony\Component\HttpFoundation\Request');
147			$request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);
148
149			$request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
150			$request->headers->shouldReceive('has')->andReturn(false);
151
152			$request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
153			$request->query->shouldReceive('has')->andReturn(false);
154
155			$responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
156			$responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
157			$responseModel->shouldReceive('setReturnStatusCode');
158			$responseModel->shouldReceive('setReturnStackTrace');
159
160			$response = m::mock('Symfony\Component\HttpFoundation\Response');
161			$response->shouldReceive('getContent')->andReturn($responseModel);
162			$response->shouldReceive('setStatusCode');
163
164			// Perform operation
165			$actualResponse = $subject->transformEarly($request, $response);
166
167			// Verify post-conditions
168			$this->assertNoException(function () use ($response) {
169			$response->shouldHaveReceived('setStatusCode')->with(Response::HTTP_CONFLICT);
170			});
171			$this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $actualResponse);
172			}
173
174			public function testTransformEarlyForceHttpOk()
175			{
176			// Get SUT
177			$subject = $this->getSubject();
178
179			// Prepare/mock pre-conditions
180			$request = m::mock('Symfony\Component\HttpFoundation\Request');
181			$request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_JSON);
182
183			$request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
184			$request->headers->shouldReceive('has')->andReturn(true);
185
186			$request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
187			$request->query->shouldReceive('has')->andReturn(false);
188
189			$responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
190			$responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
191			$responseModel->shouldReceive('setReturnStatusCode');
192			$responseModel->shouldReceive('setReturnStackTrace');
193			$responseModel->shouldReceive('toArray');
194
195			$response = m::mock('Symfony\Component\HttpFoundation\Response');
196			$response->shouldReceive('getContent')->andReturn($responseModel);
197			$response->shouldReceive('setStatusCode');
198			$response->shouldReceive('getStatusCode')->andReturn(200);
199
200			$response->headers = m::mock('Symfony\Component\HttpFoundation\ResponseHeaderBag');
201			$response->headers->shouldReceive('set');
202
203			// Perform operation
204			$subject->transformEarly($request, $response);
205
206			// Verify post-conditions
207			$this->assertNoException(function () use ($response) {
208			$response->shouldHaveReceived('setStatusCode')->with(Response::HTTP_OK);
209			});
210			}
211
212			public function testTransformEarlySerializeXml()
213			{
214			// Get SUT
215			$subject = $this->getSubject();
216
217			// Prepare/mock pre-conditions
218			$request = m::mock('Symfony\Component\HttpFoundation\Request');
219			$request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_XML);
220
221			$request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
222			$request->headers->shouldReceive('has')->andReturn(true);
223
224			$request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
225			$request->query->shouldReceive('has')->andReturn(false);
226
227			$responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
228			$responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
229			$responseModel->shouldReceive('setReturnStatusCode');
230			$responseModel->shouldReceive('setReturnStackTrace');
231			$responseModel->shouldReceive('toArray');
232
233			$response = m::mock('Symfony\Component\HttpFoundation\Response');
234			$response->shouldReceive('getContent')->andReturn($responseModel);
235			$response->shouldReceive('setStatusCode');
236			$response->shouldReceive('getStatusCode')->andReturn(200);
237			$response->shouldReceive('setContent');
238
239			$response->headers = m::mock('Symfony\Component\HttpFoundation\ResponseHeaderBag');
240			$response->headers->shouldReceive('set');
241
242			// Perform operation
243			$subject->transformEarly($request, $response);
244
245			// Verify post-conditions
246			$this->assertNoException(function () use ($response) {
247			$response->shouldHaveReceived('setStatusCode')->with(Response::HTTP_OK);
248			$response->shouldHaveReceived('setContent');
249			});
250			}
251
252			public function testTransformEarlyWOResponseModel()
253			{
254			// Get SUT
255			$subject = $this->getSubject();
256
257			// Prepare/mock pre-conditions
258			$content = 'some content';
259
260			$request = m::mock('Symfony\Component\HttpFoundation\Request');
261			$request->shouldReceive('getRequestFormat')->andReturn(Format::FORMAT_XML);
262
263			$request->headers = m::mock('Symfony\Component\HttpFoundation\HeaderBag');
264			$request->headers->shouldReceive('has')->andReturn(true);
265
266			$request->query = m::mock('Symfony\Component\HttpFoundation\ParameterBag');
267			$request->query->shouldReceive('has')->andReturn(false);
268
269			$response = m::mock('Symfony\Component\HttpFoundation\Response');
270			$response->shouldReceive('getContent')->andReturn($content);
271			$response->shouldReceive('setStatusCode');
272			$response->shouldReceive('getStatusCode')->andReturn(200);
273			$response->shouldReceive('setContent');
274
275			$response->headers = m::mock('Symfony\Component\HttpFoundation\ResponseHeaderBag');
276			$response->headers->shouldReceive('set');
277
278			$responseModel = m::mock('MediaMonks\RestApi\Model\ResponseModel');
279			$responseModel->shouldReceive('getStatusCode')->andReturn(Response::HTTP_CONFLICT);
280			$responseModel->shouldReceive('setReturnStatusCode');
281			$responseModel->shouldReceive('setReturnStackTrace');
282			$responseModel->shouldReceive('toArray');
283
284			// Perform operation
285			$subject->transformEarly($request, $response);
286
287			$factory = $this->responseModelFactory;
288
289			// Verify post-conditions
290			$this->assertNoException(function () use ($factory, $content) {
291			$factory->shouldHaveReceived('createFromContent');
292			});
293			}
294
295			protected function assertNoException($callback)
296			{
297			try {
298			$callback();
299			$this->assertTrue(true);
300			} catch (\Exception $e) {
301			$this->assertTrue(false, 'Exception thrown when none was expected. Exception message: ' . $e->getMessage());
302			}
303			}
304			}
305

mediamonks / php-rest-api

Push — master ( 8796f9...232efd )

ResponseTransformerTest::testTransformLateWrapperPostMessage() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like