ClientTest::testSendAction() - Code Metrics - thomasvargiu/pami-module - Measure and Improve Code Quality continuously with Scrutinizer

ClientTest::testSendAction() B
last analyzed 2017-12-01 16:39 UTC

↳ Parent: ClientTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	43
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	43
rs	8.8571
c	1
b	0
f	0
cc	1
eloc	31
nc	1
nop	0

<?php

namespace PamiModuleTest\Service;

use PamiModule\Service\Client;
use Zend\EventManager\Event;

class ClientTest extends \PHPUnit_Framework_TestCase
{
    public function testClient()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->getMock();

        /* @var \PAMI\Client\Impl\ClientImpl $pami */
        /* @var \Zend\EventManager\EventManager $eventManager */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);
        static::assertSame($pami, $client->getConnection());
        static::assertEquals('host', $client->getHost());

        // Test attach EventManager

        $eventManager = $client->getEventManager();
        static::assertSame($eventManager, $client->getEventManager());

        $params = ['foo' => 'bar'];
        $client->setParams($params);
        static::assertEquals($params, $client->getParams());
    }

    public function testConnect()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods(['open'])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['trigger'])
            ->getMock();

        $pami->expects(static::once())
            ->method('open');

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(false);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::exactly(2))
            ->method('trigger')
            ->withConsecutive(
                ['connect.pre', $client],
                ['connect.post', $client]
            )
            ->will(static::returnValue($eventResults));

        $result = $client->connect();
        static::assertSame($client, $result);
    }

    public function testConnectStopped()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods([])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['trigger'])
            ->getMock();

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(true);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::once())
            ->method('trigger')
            ->with('connect.pre', $client)
            ->willReturn($eventResults);

        $result = $client->connect();
        static::assertSame($client, $result);
    }

    public function testDisconnect()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods(['close'])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['trigger'])
            ->getMock();

        $pami->expects(static::once())
            ->method('close');

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(false);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::exactly(2))
            ->method('trigger')
            ->withConsecutive(
                ['disconnect.pre', $client],
                ['disconnect.post', $client]
            )
            ->willReturn($eventResults);

        $result = $client->disconnect();
        static::assertSame($client, $result);
    }

    public function testDisconnectStopped()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods([])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['trigger'])
            ->getMock();

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(true);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::once())
            ->method('trigger')
            ->with('disconnect.pre', $client)
            ->willReturn($eventResults);

        $result = $client->disconnect();
        static::assertSame($client, $result);
    }

    public function testProcess()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods(['process'])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['trigger', 'stopped'])
            ->getMock();

        $pami->expects(static::once())
            ->method('process');

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(false);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::exactly(2))
            ->method('trigger')
            ->withConsecutive(
                ['process.pre', $client],
                ['process.post', $client]
            )
        ->willReturn($eventResults);

        $result = $client->process();
        static::assertSame($client, $result);
    }

    public function testProcessStopped()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods([])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['trigger'])
            ->getMock();

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(true);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::once())
            ->method('trigger')
            ->with('process.pre', $client)
            ->willReturn($eventResults);

        $result = $client->process();
        static::assertSame($client, $result);
    }

    public function testSendAction()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods(['send'])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['trigger', 'triggerEventUntil'])
            ->getMock();

        $action = $this->getMockBuilder('PAMI\\Message\\OutgoingMessage')
            ->disableOriginalConstructor()
            ->getMock();

        $pami->expects(static::once())
            ->method('send')
            ->with($action)
            ->willReturn('foo');

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(false);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::exactly(1))
            ->method('triggerEventUntil')
            ->with(static::isType('callable'), static::isInstanceOf(Event::class))
            ->willReturn($eventResults);

        $eventManager->expects(static::exactly(1))
            ->method('trigger')
            ->with('sendAction.post', $client, static::isInstanceOf('ArrayObject'));

        $result = $client->sendAction($action);
        static::assertEquals('foo', $result);
    }

    public function testSendActionStopped()
    {
        $pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
            ->disableOriginalConstructor()
            ->setMethods([])
            ->getMock();

        $eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
            ->setMethods(['triggerEventUntil'])
            ->getMock();

        $action = $this->getMockBuilder('PAMI\\Message\\OutgoingMessage')
            ->disableOriginalConstructor()
            ->getMock();

        $response = $this->getMockBuilder('PAMI\\Message\\Response\\ResponseMessage')
            ->disableOriginalConstructor()
            ->getMock();

        $eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
            ->disableOriginalConstructor()
            ->setMethods(['stopped', 'last'])
            ->getMock();
        $eventResults->expects(static::once())->method('stopped')->willReturn(true);
        $eventResults->expects(static::once())->method('last')->willReturn($response);

        /* @var \PAMI\Client\Impl\ClientImpl $pami */

        $client = new Client('host', $pami);
        $client->setEventManager($eventManager);

        $eventManager->expects(static::exactly(1))
            ->method('triggerEventUntil')
            ->with(static::callback(
                function ($callback) use ($response) {
                    static::assertFalse($callback(null));
                    static::assertFalse($callback('string'));
                    static::assertFalse($callback([]));
                    static::assertTrue($callback($response));

                    return true;
                }
            ), static::isInstanceOf(Event::class)
            )
            ->willReturn($eventResults);

        $result = $client->sendAction($action);
        static::assertSame($response, $result);
    }
}


1			<?php
2
3			namespace PamiModuleTest\Service;
4
5			use PamiModule\Service\Client;
6			use Zend\EventManager\Event;
7
8			class ClientTest extends \PHPUnit_Framework_TestCase
9			{
10			public function testClient()
11			{
12			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
13			->disableOriginalConstructor()
14			->getMock();
15
16			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
17			->getMock();
18
19			/* @var \PAMI\Client\Impl\ClientImpl $pami */
20			/* @var \Zend\EventManager\EventManager $eventManager */
21
22			$client = new Client('host', $pami);
23			$client->setEventManager($eventManager);
24			static::assertSame($pami, $client->getConnection());
25			static::assertEquals('host', $client->getHost());
26
27			// Test attach EventManager
28
29			$eventManager = $client->getEventManager();
30			static::assertSame($eventManager, $client->getEventManager());
31
32			$params = ['foo' => 'bar'];
33			$client->setParams($params);
34			static::assertEquals($params, $client->getParams());
35			}
36
37			public function testConnect()
38			{
39			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
40			->disableOriginalConstructor()
41			->setMethods(['open'])
42			->getMock();
43
44			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
45			->setMethods(['trigger'])
46			->getMock();
47
48			$pami->expects(static::once())
49			->method('open');
50
51			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
52			->disableOriginalConstructor()
53			->setMethods(['stopped'])
54			->getMock();
55			$eventResults->expects(static::once())->method('stopped')->willReturn(false);
56
57			/* @var \PAMI\Client\Impl\ClientImpl $pami */
58
59			$client = new Client('host', $pami);
60			$client->setEventManager($eventManager);
61
62			$eventManager->expects(static::exactly(2))
63			->method('trigger')
64			->withConsecutive(
65			['connect.pre', $client],
66			['connect.post', $client]
67			)
68			->will(static::returnValue($eventResults));
69
70			$result = $client->connect();
71			static::assertSame($client, $result);
72			}
73
74			public function testConnectStopped()
75			{
76			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
77			->disableOriginalConstructor()
78			->setMethods([])
79			->getMock();
80
81			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
82			->setMethods(['trigger'])
83			->getMock();
84
85			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
86			->disableOriginalConstructor()
87			->setMethods(['stopped'])
88			->getMock();
89			$eventResults->expects(static::once())->method('stopped')->willReturn(true);
90
91			/* @var \PAMI\Client\Impl\ClientImpl $pami */
92
93			$client = new Client('host', $pami);
94			$client->setEventManager($eventManager);
95
96			$eventManager->expects(static::once())
97			->method('trigger')
98			->with('connect.pre', $client)
99			->willReturn($eventResults);
100
101			$result = $client->connect();
102			static::assertSame($client, $result);
103			}
104
105			public function testDisconnect()
106			{
107			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
108			->disableOriginalConstructor()
109			->setMethods(['close'])
110			->getMock();
111
112			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
113			->setMethods(['trigger'])
114			->getMock();
115
116			$pami->expects(static::once())
117			->method('close');
118
119			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
120			->disableOriginalConstructor()
121			->setMethods(['stopped'])
122			->getMock();
123			$eventResults->expects(static::once())->method('stopped')->willReturn(false);
124
125			/* @var \PAMI\Client\Impl\ClientImpl $pami */
126
127			$client = new Client('host', $pami);
128			$client->setEventManager($eventManager);
129
130			$eventManager->expects(static::exactly(2))
131			->method('trigger')
132			->withConsecutive(
133			['disconnect.pre', $client],
134			['disconnect.post', $client]
135			)
136			->willReturn($eventResults);
137
138			$result = $client->disconnect();
139			static::assertSame($client, $result);
140			}
141
142			public function testDisconnectStopped()
143			{
144			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
145			->disableOriginalConstructor()
146			->setMethods([])
147			->getMock();
148
149			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
150			->setMethods(['trigger'])
151			->getMock();
152
153			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
154			->disableOriginalConstructor()
155			->setMethods(['stopped'])
156			->getMock();
157			$eventResults->expects(static::once())->method('stopped')->willReturn(true);
158
159			/* @var \PAMI\Client\Impl\ClientImpl $pami */
160
161			$client = new Client('host', $pami);
162			$client->setEventManager($eventManager);
163
164			$eventManager->expects(static::once())
165			->method('trigger')
166			->with('disconnect.pre', $client)
167			->willReturn($eventResults);
168
169			$result = $client->disconnect();
170			static::assertSame($client, $result);
171			}
172
173			public function testProcess()
174			{
175			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
176			->disableOriginalConstructor()
177			->setMethods(['process'])
178			->getMock();
179
180			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
181			->setMethods(['trigger', 'stopped'])
182			->getMock();
183
184			$pami->expects(static::once())
185			->method('process');
186
187			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
188			->disableOriginalConstructor()
189			->setMethods(['stopped'])
190			->getMock();
191			$eventResults->expects(static::once())->method('stopped')->willReturn(false);
192
193			/* @var \PAMI\Client\Impl\ClientImpl $pami */
194
195			$client = new Client('host', $pami);
196			$client->setEventManager($eventManager);
197
198			$eventManager->expects(static::exactly(2))
199			->method('trigger')
200			->withConsecutive(
201			['process.pre', $client],
202			['process.post', $client]
203			)
204			->willReturn($eventResults);
205
206			$result = $client->process();
207			static::assertSame($client, $result);
208			}
209
210			public function testProcessStopped()
211			{
212			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
213			->disableOriginalConstructor()
214			->setMethods([])
215			->getMock();
216
217			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
218			->setMethods(['trigger'])
219			->getMock();
220
221			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
222			->disableOriginalConstructor()
223			->setMethods(['stopped'])
224			->getMock();
225			$eventResults->expects(static::once())->method('stopped')->willReturn(true);
226
227			/* @var \PAMI\Client\Impl\ClientImpl $pami */
228
229			$client = new Client('host', $pami);
230			$client->setEventManager($eventManager);
231
232			$eventManager->expects(static::once())
233			->method('trigger')
234			->with('process.pre', $client)
235			->willReturn($eventResults);
236
237			$result = $client->process();
238			static::assertSame($client, $result);
239			}
240
241			public function testSendAction()
242			{
243			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
244			->disableOriginalConstructor()
245			->setMethods(['send'])
246			->getMock();
247
248			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
249			->setMethods(['trigger', 'triggerEventUntil'])
250			->getMock();
251
252			$action = $this->getMockBuilder('PAMI\\Message\\OutgoingMessage')
253			->disableOriginalConstructor()
254			->getMock();
255
256			$pami->expects(static::once())
257			->method('send')
258			->with($action)
259			->willReturn('foo');
260
261			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
262			->disableOriginalConstructor()
263			->setMethods(['stopped'])
264			->getMock();
265			$eventResults->expects(static::once())->method('stopped')->willReturn(false);
266
267			/* @var \PAMI\Client\Impl\ClientImpl $pami */
268
269			$client = new Client('host', $pami);
270			$client->setEventManager($eventManager);
271
272			$eventManager->expects(static::exactly(1))
273			->method('triggerEventUntil')
274			->with(static::isType('callable'), static::isInstanceOf(Event::class))
275			->willReturn($eventResults);
276
277			$eventManager->expects(static::exactly(1))
278			->method('trigger')
279			->with('sendAction.post', $client, static::isInstanceOf('ArrayObject'));
280
281			$result = $client->sendAction($action);
282			static::assertEquals('foo', $result);
283			}
284
285			public function testSendActionStopped()
286			{
287			$pami = $this->getMockBuilder('PAMI\\Client\\Impl\\ClientImpl')
288			->disableOriginalConstructor()
289			->setMethods([])
290			->getMock();
291
292			$eventManager = $this->getMockBuilder('Zend\\EventManager\\EventManager')
293			->setMethods(['triggerEventUntil'])
294			->getMock();
295
296			$action = $this->getMockBuilder('PAMI\\Message\\OutgoingMessage')
297			->disableOriginalConstructor()
298			->getMock();
299
300			$response = $this->getMockBuilder('PAMI\\Message\\Response\\ResponseMessage')
301			->disableOriginalConstructor()
302			->getMock();
303
304			$eventResults = $this->getMockBuilder('Zend\\EventManager\\ResponseCollection')
305			->disableOriginalConstructor()
306			->setMethods(['stopped', 'last'])
307			->getMock();
308			$eventResults->expects(static::once())->method('stopped')->willReturn(true);
309			$eventResults->expects(static::once())->method('last')->willReturn($response);
310
311			/* @var \PAMI\Client\Impl\ClientImpl $pami */
312
313			$client = new Client('host', $pami);
314			$client->setEventManager($eventManager);
315
316			$eventManager->expects(static::exactly(1))
317			->method('triggerEventUntil')
318			->with(static::callback(
319			function ($callback) use ($response) {
320			static::assertFalse($callback(null));
321			static::assertFalse($callback('string'));
322			static::assertFalse($callback([]));
323			static::assertTrue($callback($response));
324
325			return true;
326			}
327			), static::isInstanceOf(Event::class)
328			)
329			->willReturn($eventResults);
330
331			$result = $client->sendAction($action);
332			static::assertSame($response, $result);
333			}
334			}
335

thomasvargiu / pami-module

ClientTest::testSendAction() B last analyzed 2017-12-01 16:39 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ClientTest::testSendAction() B
last analyzed 2017-12-01 16:39 UTC