InPlacePagerPersisterTest::testShouldDispatchOnExceptionEventWithExpectedArgumentsAndReThrowIt() - Code Metrics - Inspection of "4x to master" - FriendsOfSymfony/FOSElasticaBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1333)

by Maksim

created 2017-12-11 19:29 UTC

testShouldDispatchOnExceptionEventWithExpectedArgumentsAndReThrowIt() A

↳ Parent: InPlacePagerPersisterTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	48
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	48
rs	9.125
c	0
b	0
f	0
cc	2
eloc	30
nc	2
nop	0

<?php
namespace FOS\ElasticaBundle\Tests\Persister;

use FOS\ElasticaBundle\Persister\Event\Events;
use FOS\ElasticaBundle\Persister\InPlacePagerPersister;
use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
use FOS\ElasticaBundle\Persister\Event\OnExceptionEvent;
use FOS\ElasticaBundle\Persister\PagerPersisterInterface;
use FOS\ElasticaBundle\Persister\PersisterRegistry;
use FOS\ElasticaBundle\Persister\Event\PostInsertObjectsEvent;
use FOS\ElasticaBundle\Persister\Event\PostPersistEvent;
use FOS\ElasticaBundle\Persister\Event\PreFetchObjectsEvent;
use FOS\ElasticaBundle\Persister\Event\PreInsertObjectsEvent;
use FOS\ElasticaBundle\Persister\Event\PrePersistEvent;
use FOS\ElasticaBundle\Provider\PagerfantaPager;
use Pagerfanta\Adapter\ArrayAdapter;
use Pagerfanta\Pagerfanta;
use Symfony\Component\EventDispatcher\EventDispatcher;

class InPlacePagerPersisterTest extends \PHPUnit_Framework_TestCase
{
    public function testShouldImplementPagerPersisterInterface()
    {
        $rc = new \ReflectionClass(InPlacePagerPersister::class);

        $this->assertTrue($rc->implementsInterface(PagerPersisterInterface::class));
    }

    public function testCouldBeConstructedWithPersisterRegistryAndDispatcherAsArguments()
    {
        new InPlacePagerPersister($this->createPersisterRegistryMock(), new EventDispatcher());

    }

    public function testShouldDispatchPrePersistEventWithExpectedArguments()
    {
        $objectPersisterMock = $this->createObjectPersisterMock();

        $options = ['indexName' => 'theIndex', 'typeName' => 'theType'];

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
        $dispatcher = new EventDispatcher();

        $persister = new InPlacePagerPersister($registryMock, $dispatcher);

        $pager = $this->createPager([new \stdClass(), new \stdClass()]);

        $called = false;
        $dispatcher->addListener(Events::PRE_PERSIST, function($event) use(&$called, $pager, $objectPersisterMock, $options) {
            $called = true;

            $this->assertInstanceOf(PrePersistEvent::class, $event);
            $this->assertSame($pager, $event->getPager());
            $this->assertSame($objectPersisterMock, $event->getObjectPersister());
            $this->assertSame(
                ['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
                $event->getOptions()
            );
        });

        $persister->insert($pager, $options);

        $this->assertTrue($called);
    }

    public function testShouldDispatchPreFetchObjectsEventWithExpectedArguments()
    {
        $objectPersisterMock = $this->createObjectPersisterMock();

        $options = ['indexName' => 'theIndex', 'typeName' => 'theType'];

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
        $dispatcher = new EventDispatcher();

        $persister = new InPlacePagerPersister($registryMock, $dispatcher);

        $objects = [new \stdClass(), new \stdClass()];

        $pager = $this->createPager($objects);

        $called = false;
        $dispatcher->addListener(Events::PRE_FETCH_OBJECTS, function($event) use(&$called, $pager, $objectPersisterMock, $options) {
            $called = true;

            $this->assertInstanceOf(PreFetchObjectsEvent::class, $event);
            $this->assertSame($pager, $event->getPager());
            $this->assertSame($objectPersisterMock, $event->getObjectPersister());
            $this->assertSame(
                ['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
                $event->getOptions()
            );
        });

        $persister->insert($pager, $options);

        $this->assertTrue($called);
    }

    public function testShouldDispatchPreInsertObjectsEventWithExpectedArguments()
    {
        $objectPersisterMock = $this->createObjectPersisterMock();

        $options = ['indexName' => 'theIndex', 'typeName' => 'theType'];

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
        $dispatcher = new EventDispatcher();

        $persister = new InPlacePagerPersister($registryMock, $dispatcher);

        $objects = [new \stdClass(), new \stdClass()];

        $pager = $this->createPager($objects);

        $called = false;
        $dispatcher->addListener(Events::PRE_INSERT_OBJECTS, function($event) use(&$called, $pager, $objectPersisterMock, $objects, $options) {
            $called = true;

            $this->assertInstanceOf(PreInsertObjectsEvent::class, $event);
            $this->assertSame($pager, $event->getPager());
            $this->assertSame($objectPersisterMock, $event->getObjectPersister());
            $this->assertSame(
                ['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
                $event->getOptions()
            );
            $this->assertSame($objects, $event->getObjects());
        });

        $persister->insert($pager, $options);

        $this->assertTrue($called);
    }

    public function testShouldDispatchPostInsertObjectsEventWithExpectedArguments()
    {
        $objectPersisterMock = $this->createObjectPersisterMock();

        $options = ['indexName' => 'theIndex', 'typeName' => 'theType'];

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
        $dispatcher = new EventDispatcher();

        $persister = new InPlacePagerPersister($registryMock, $dispatcher);

        $objects = [new \stdClass(), new \stdClass()];

        $pager = $this->createPager($objects);

        $called = false;
        $dispatcher->addListener(Events::POST_INSERT_OBJECTS, function($event) use(&$called, $pager, $objectPersisterMock, $objects, $options) {
            $called = true;

            $this->assertInstanceOf(PostInsertObjectsEvent::class, $event);
            $this->assertSame($pager, $event->getPager());
            $this->assertSame($objectPersisterMock, $event->getObjectPersister());
            $this->assertSame(
                ['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
                $event->getOptions()
            );
            $this->assertSame($objects, $event->getObjects());
        });

        $persister->insert($pager, $options);

        $this->assertTrue($called);
    }

    public function testShouldDispatchPostPersistEventWithExpectedArguments()
    {
        $objectPersisterMock = $this->createObjectPersisterMock();

        $options = ['indexName' => 'theIndex', 'typeName' => 'theType'];

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
        $dispatcher = new EventDispatcher();

        $persister = new InPlacePagerPersister($registryMock, $dispatcher);

        $objects = [new \stdClass(), new \stdClass()];

        $pager = $this->createPager($objects);

        $called = false;
        $dispatcher->addListener(Events::POST_PERSIST, function($event) use(&$called, $pager, $objectPersisterMock, $objects, $options) {
            $called = true;

            $this->assertInstanceOf(PostPersistEvent::class, $event);
            $this->assertSame($pager, $event->getPager());
            $this->assertSame($objectPersisterMock, $event->getObjectPersister());
            $this->assertSame(
                ['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
                $event->getOptions()
            );
        });

        $persister->insert($pager, $options);

        $this->assertTrue($called);
    }

    public function testShouldCallObjectPersisterInsertManyMethodForEachPage()
    {
        $options = ['indexName' => 'theIndex', 'typeName' => 'theType', 'batch_size' => 2];

        $firstPage = [new \stdClass(), new \stdClass()];
        $secondPage = [new \stdClass(), new \stdClass()];
        $thirdPage = [new \stdClass(), new \stdClass()];

        $objects = [$firstPage[0], $firstPage[1], $secondPage[0], $secondPage[1], $thirdPage[0], $thirdPage[1]];

        $objectPersisterMock = $this->createObjectPersisterMock();
        $objectPersisterMock
            ->expects($this->exactly(3))
            ->method('insertMany')
            ->withConsecutive($this->identicalTo([$firstPage]), $this->identicalTo([$secondPage]), $this->identicalTo([$thirdPage]))
        ;

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);

        $persister = new InPlacePagerPersister($registryMock, new EventDispatcher());

        $pager = $this->createPager($objects);

        $persister->insert($pager, $options);
    }

    public function testShouldCallObjectPersisterInsertManyMethodOnlyForSecondPage()
    {
        $options = [
            'indexName' => 'theIndex',
            'typeName' => 'theType',
            'batch_size' => 2,
            'first_page' => 2,
            'last_page' => 2,
        ];

        $firstPage = [new \stdClass(), new \stdClass()];
        $secondPage = [new \stdClass(), new \stdClass()];
        $thirdPage = [new \stdClass(), new \stdClass()];

        $objects = [$firstPage[0], $firstPage[1], $secondPage[0], $secondPage[1], $thirdPage[0], $thirdPage[1]];

        $objectPersisterMock = $this->createObjectPersisterMock();
        $objectPersisterMock
            ->expects($this->once())
            ->method('insertMany')
            ->withConsecutive($this->identicalTo([$secondPage]))
        ;

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);

        $persister = new InPlacePagerPersister($registryMock, new EventDispatcher());

        $pager = $this->createPager($objects);

        $persister->insert($pager, $options);
    }

    public function testShouldDispatchOnExceptionEventWithExpectedArgumentsAndReThrowIt()
    {
        $exception = new \LogicException();

        $objectPersisterMock = $this->createObjectPersisterMock();
        $objectPersisterMock
            ->expects($this->once())
            ->method('insertMany')
            ->willThrowException($exception)
        ;


        $options = ['indexName' => 'theIndex', 'typeName' => 'theType'];

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
        $dispatcher = new EventDispatcher();

        $persister = new InPlacePagerPersister($registryMock, $dispatcher);

        $objects = [new \stdClass(), new \stdClass()];

        $pager = $this->createPager($objects);

        $called = false;
        $dispatcher->addListener(Events::ON_EXCEPTION, function($event) use(&$called, $pager, $objectPersisterMock, $exception, $options) {
            $called = true;

            $this->assertInstanceOf(OnExceptionEvent::class, $event);
            $this->assertSame($pager, $event->getPager());
            $this->assertSame($objectPersisterMock, $event->getObjectPersister());
            $this->assertSame(
                ['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
                $event->getOptions()
            );
            $this->assertSame($exception, $event->getException());
        });

        try {
            $persister->insert($pager, $options);
        } catch (\Exception $e) {
            $this->assertTrue($called);
            $this->assertSame($exception, $e);

            return;
        }

        $this->fail('The exception is expected to be thrown');
    }

    public function testShouldDispatchOnExceptionEventButNotReThrowIt()
    {
        $exception = new \LogicException();

        $objectPersisterMock = $this->createObjectPersisterMock();
        $objectPersisterMock
            ->expects($this->once())
            ->method('insertMany')
            ->willThrowException($exception)
        ;


        $options = ['indexName' => 'theIndex', 'typeName' => 'theType'];

        $registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
        $dispatcher = new EventDispatcher();

        $persister = new InPlacePagerPersister($registryMock, $dispatcher);

        $objects = [new \stdClass(), new \stdClass()];

        $pager = $this->createPager($objects);

        $called = false;
        $dispatcher->addListener(Events::ON_EXCEPTION, function(OnExceptionEvent $event) use(&$called) {
            $called = true;

            $event->setIgnore(true);
        });

        $persister->insert($pager, $options);

        $this->assertTrue($called);
    }

    private function createPager(array $objects)
    {
        return new PagerfantaPager(new Pagerfanta(new ArrayAdapter($objects)));
    }

    /**
     * @return ObjectPersisterInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createObjectPersisterMock()
    {
        return $this->getMock(ObjectPersisterInterface::class, [], [], '', false);

    }

    /**
     * @return PersisterRegistry|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createPersisterRegistryMock()
    {
        return $this->getMock(PersisterRegistry::class, [], [], '', false);

    }

    /**
     * @return PersisterRegistry|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createPersisterRegistryStub($objectPersister = null)
    {
        $registryMock = $this->createPersisterRegistryMock();
        $registryMock
            ->expects($this->once())
            ->method('getPersister')
            ->with('theIndex', 'theType')
            ->willReturn($objectPersister)
        ;

        return $registryMock;
    }
}

1		<?php
2		namespace FOS\ElasticaBundle\Tests\Persister;
3
4		use FOS\ElasticaBundle\Persister\Event\Events;
5		use FOS\ElasticaBundle\Persister\InPlacePagerPersister;
6		use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
7		use FOS\ElasticaBundle\Persister\Event\OnExceptionEvent;
8		use FOS\ElasticaBundle\Persister\PagerPersisterInterface;
9		use FOS\ElasticaBundle\Persister\PersisterRegistry;
10		use FOS\ElasticaBundle\Persister\Event\PostInsertObjectsEvent;
11		use FOS\ElasticaBundle\Persister\Event\PostPersistEvent;
12		use FOS\ElasticaBundle\Persister\Event\PreFetchObjectsEvent;
13		use FOS\ElasticaBundle\Persister\Event\PreInsertObjectsEvent;
14		use FOS\ElasticaBundle\Persister\Event\PrePersistEvent;
15		use FOS\ElasticaBundle\Provider\PagerfantaPager;
16		use Pagerfanta\Adapter\ArrayAdapter;
17		use Pagerfanta\Pagerfanta;
18		use Symfony\Component\EventDispatcher\EventDispatcher;
19
20		class InPlacePagerPersisterTest extends \PHPUnit_Framework_TestCase
21		{
22		public function testShouldImplementPagerPersisterInterface()
23		{
24		$rc = new \ReflectionClass(InPlacePagerPersister::class);
25
26		$this->assertTrue($rc->implementsInterface(PagerPersisterInterface::class));
27		}
28
29		public function testCouldBeConstructedWithPersisterRegistryAndDispatcherAsArguments()
30		{
31		new InPlacePagerPersister($this->createPersisterRegistryMock(), new EventDispatcher());
		0 ignored issues – show Bug introduced 2017-12-06 21:20 UTC by Report Bug Copy Issue Report It seems like `$this->createPersisterRegistryMock()` targeting `FOS\ElasticaBundle\Tests...PersisterRegistryMock()` can also be of type `object<PHPUnit_Framework_MockObject_MockObject>`; however, `FOS\ElasticaBundle\Persi...ersister::__construct()` does only seem to accept `object<FOS\ElasticaBundl...ster\PersisterRegistry>`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
32		}
33
34		public function testShouldDispatchPrePersistEventWithExpectedArguments()
35		{
36		$objectPersisterMock = $this->createObjectPersisterMock();
37
38		$options = ['indexName' => 'theIndex', 'typeName' => 'theType'];
39
40		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
41		$dispatcher = new EventDispatcher();
42
43		$persister = new InPlacePagerPersister($registryMock, $dispatcher);
44
45		$pager = $this->createPager([new \stdClass(), new \stdClass()]);
46
47		$called = false;
48		$dispatcher->addListener(Events::PRE_PERSIST, function($event) use(&$called, $pager, $objectPersisterMock, $options) {
49		$called = true;
50
51		$this->assertInstanceOf(PrePersistEvent::class, $event);
52		$this->assertSame($pager, $event->getPager());
53		$this->assertSame($objectPersisterMock, $event->getObjectPersister());
54		$this->assertSame(
55		['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
56		$event->getOptions()
57		);
58		});
59
60		$persister->insert($pager, $options);
61
62		$this->assertTrue($called);
63		}
64
65		public function testShouldDispatchPreFetchObjectsEventWithExpectedArguments()
66		{
67		$objectPersisterMock = $this->createObjectPersisterMock();
68
69		$options = ['indexName' => 'theIndex', 'typeName' => 'theType'];
70
71		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
72		$dispatcher = new EventDispatcher();
73
74		$persister = new InPlacePagerPersister($registryMock, $dispatcher);
75
76		$objects = [new \stdClass(), new \stdClass()];
77
78		$pager = $this->createPager($objects);
79
80		$called = false;
81		$dispatcher->addListener(Events::PRE_FETCH_OBJECTS, function($event) use(&$called, $pager, $objectPersisterMock, $options) {
82		$called = true;
83
84		$this->assertInstanceOf(PreFetchObjectsEvent::class, $event);
85		$this->assertSame($pager, $event->getPager());
86		$this->assertSame($objectPersisterMock, $event->getObjectPersister());
87		$this->assertSame(
88		['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
89		$event->getOptions()
90		);
91		});
92
93		$persister->insert($pager, $options);
94
95		$this->assertTrue($called);
96		}
97
98	View Code Duplication	public function testShouldDispatchPreInsertObjectsEventWithExpectedArguments()
99		{
100		$objectPersisterMock = $this->createObjectPersisterMock();
101
102		$options = ['indexName' => 'theIndex', 'typeName' => 'theType'];
103
104		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
105		$dispatcher = new EventDispatcher();
106
107		$persister = new InPlacePagerPersister($registryMock, $dispatcher);
108
109		$objects = [new \stdClass(), new \stdClass()];
110
111		$pager = $this->createPager($objects);
112
113		$called = false;
114		$dispatcher->addListener(Events::PRE_INSERT_OBJECTS, function($event) use(&$called, $pager, $objectPersisterMock, $objects, $options) {
115		$called = true;
116
117		$this->assertInstanceOf(PreInsertObjectsEvent::class, $event);
118		$this->assertSame($pager, $event->getPager());
119		$this->assertSame($objectPersisterMock, $event->getObjectPersister());
120		$this->assertSame(
121		['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
122		$event->getOptions()
123		);
124		$this->assertSame($objects, $event->getObjects());
125		});
126
127		$persister->insert($pager, $options);
128
129		$this->assertTrue($called);
130		}
131
132	View Code Duplication	public function testShouldDispatchPostInsertObjectsEventWithExpectedArguments()
133		{
134		$objectPersisterMock = $this->createObjectPersisterMock();
135
136		$options = ['indexName' => 'theIndex', 'typeName' => 'theType'];
137
138		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
139		$dispatcher = new EventDispatcher();
140
141		$persister = new InPlacePagerPersister($registryMock, $dispatcher);
142
143		$objects = [new \stdClass(), new \stdClass()];
144
145		$pager = $this->createPager($objects);
146
147		$called = false;
148		$dispatcher->addListener(Events::POST_INSERT_OBJECTS, function($event) use(&$called, $pager, $objectPersisterMock, $objects, $options) {
149		$called = true;
150
151		$this->assertInstanceOf(PostInsertObjectsEvent::class, $event);
152		$this->assertSame($pager, $event->getPager());
153		$this->assertSame($objectPersisterMock, $event->getObjectPersister());
154		$this->assertSame(
155		['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
156		$event->getOptions()
157		);
158		$this->assertSame($objects, $event->getObjects());
159		});
160
161		$persister->insert($pager, $options);
162
163		$this->assertTrue($called);
164		}
165
166	View Code Duplication	public function testShouldDispatchPostPersistEventWithExpectedArguments()
167		{
168		$objectPersisterMock = $this->createObjectPersisterMock();
169
170		$options = ['indexName' => 'theIndex', 'typeName' => 'theType'];
171
172		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
173		$dispatcher = new EventDispatcher();
174
175		$persister = new InPlacePagerPersister($registryMock, $dispatcher);
176
177		$objects = [new \stdClass(), new \stdClass()];
178
179		$pager = $this->createPager($objects);
180
181		$called = false;
182		$dispatcher->addListener(Events::POST_PERSIST, function($event) use(&$called, $pager, $objectPersisterMock, $objects, $options) {
183		$called = true;
184
185		$this->assertInstanceOf(PostPersistEvent::class, $event);
186		$this->assertSame($pager, $event->getPager());
187		$this->assertSame($objectPersisterMock, $event->getObjectPersister());
188		$this->assertSame(
189		['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
190		$event->getOptions()
191		);
192		});
193
194		$persister->insert($pager, $options);
195
196		$this->assertTrue($called);
197		}
198
199		public function testShouldCallObjectPersisterInsertManyMethodForEachPage()
200		{
201		$options = ['indexName' => 'theIndex', 'typeName' => 'theType', 'batch_size' => 2];
202
203		$firstPage = [new \stdClass(), new \stdClass()];
204		$secondPage = [new \stdClass(), new \stdClass()];
205		$thirdPage = [new \stdClass(), new \stdClass()];
206
207		$objects = [$firstPage[0], $firstPage[1], $secondPage[0], $secondPage[1], $thirdPage[0], $thirdPage[1]];
208
209		$objectPersisterMock = $this->createObjectPersisterMock();
210		$objectPersisterMock
211		->expects($this->exactly(3))
212		->method('insertMany')
213		->withConsecutive($this->identicalTo([$firstPage]), $this->identicalTo([$secondPage]), $this->identicalTo([$thirdPage]))
214		;
215
216		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
217
218		$persister = new InPlacePagerPersister($registryMock, new EventDispatcher());
219
220		$pager = $this->createPager($objects);
221
222		$persister->insert($pager, $options);
223		}
224
225		public function testShouldCallObjectPersisterInsertManyMethodOnlyForSecondPage()
226		{
227		$options = [
228		'indexName' => 'theIndex',
229		'typeName' => 'theType',
230		'batch_size' => 2,
231		'first_page' => 2,
232		'last_page' => 2,
233		];
234
235		$firstPage = [new \stdClass(), new \stdClass()];
236		$secondPage = [new \stdClass(), new \stdClass()];
237		$thirdPage = [new \stdClass(), new \stdClass()];
238
239		$objects = [$firstPage[0], $firstPage[1], $secondPage[0], $secondPage[1], $thirdPage[0], $thirdPage[1]];
240
241		$objectPersisterMock = $this->createObjectPersisterMock();
242		$objectPersisterMock
243		->expects($this->once())
244		->method('insertMany')
245		->withConsecutive($this->identicalTo([$secondPage]))
246		;
247
248		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
249
250		$persister = new InPlacePagerPersister($registryMock, new EventDispatcher());
251
252		$pager = $this->createPager($objects);
253
254		$persister->insert($pager, $options);
255		}
256
257		public function testShouldDispatchOnExceptionEventWithExpectedArgumentsAndReThrowIt()
258		{
259		$exception = new \LogicException();
260
261		$objectPersisterMock = $this->createObjectPersisterMock();
262		$objectPersisterMock
263		->expects($this->once())
264		->method('insertMany')
265		->willThrowException($exception)
266		;
267
268
269		$options = ['indexName' => 'theIndex', 'typeName' => 'theType'];
270
271		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
272		$dispatcher = new EventDispatcher();
273
274		$persister = new InPlacePagerPersister($registryMock, $dispatcher);
275
276		$objects = [new \stdClass(), new \stdClass()];
277
278		$pager = $this->createPager($objects);
279
280		$called = false;
281		$dispatcher->addListener(Events::ON_EXCEPTION, function($event) use(&$called, $pager, $objectPersisterMock, $exception, $options) {
282		$called = true;
283
284		$this->assertInstanceOf(OnExceptionEvent::class, $event);
285		$this->assertSame($pager, $event->getPager());
286		$this->assertSame($objectPersisterMock, $event->getObjectPersister());
287		$this->assertSame(
288		['batch_size' => 100, 'first_page' => 1, 'last_page' => 1] + $options,
289		$event->getOptions()
290		);
291		$this->assertSame($exception, $event->getException());
292		});
293
294		try {
295		$persister->insert($pager, $options);
296		} catch (\Exception $e) {
297		$this->assertTrue($called);
298		$this->assertSame($exception, $e);
299
300		return;
301		}
302
303		$this->fail('The exception is expected to be thrown');
304		}
305
306		public function testShouldDispatchOnExceptionEventButNotReThrowIt()
307		{
308		$exception = new \LogicException();
309
310		$objectPersisterMock = $this->createObjectPersisterMock();
311		$objectPersisterMock
312		->expects($this->once())
313		->method('insertMany')
314		->willThrowException($exception)
315		;
316
317
318		$options = ['indexName' => 'theIndex', 'typeName' => 'theType'];
319
320		$registryMock = $this->createPersisterRegistryStub($objectPersisterMock);
321		$dispatcher = new EventDispatcher();
322
323		$persister = new InPlacePagerPersister($registryMock, $dispatcher);
324
325		$objects = [new \stdClass(), new \stdClass()];
326
327		$pager = $this->createPager($objects);
328
329		$called = false;
330		$dispatcher->addListener(Events::ON_EXCEPTION, function(OnExceptionEvent $event) use(&$called) {
331		$called = true;
332
333		$event->setIgnore(true);
334		});
335
336		$persister->insert($pager, $options);
337
338		$this->assertTrue($called);
339		}
340
341		private function createPager(array $objects)
342		{
343		return new PagerfantaPager(new Pagerfanta(new ArrayAdapter($objects)));
344		}
345
346		/**
347		* @return ObjectPersisterInterface\|\PHPUnit_Framework_MockObject_MockObject
348		*/
349		private function createObjectPersisterMock()
350		{
351		return $this->getMock(ObjectPersisterInterface::class, [], [], '', false);
		0 ignored issues – show Deprecated Code introduced 2017-12-11 19:33 UTC by Report Bug Copy Issue Report The method `PHPUnit_Framework_TestCase::getMock()` has been deprecated with message: Method deprecated since Release 5.4.0; use createMock() or getMockBuilder() instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
352		}
353
354		/**
355		* @return PersisterRegistry\|\PHPUnit_Framework_MockObject_MockObject
356		*/
357		private function createPersisterRegistryMock()
358		{
359		return $this->getMock(PersisterRegistry::class, [], [], '', false);
		0 ignored issues – show Deprecated Code introduced 2017-12-06 21:20 UTC by Report Bug Copy Issue Report The method `PHPUnit_Framework_TestCase::getMock()` has been deprecated with message: Method deprecated since Release 5.4.0; use createMock() or getMockBuilder() instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
360		}
361
362		/**
363		* @return PersisterRegistry\|\PHPUnit_Framework_MockObject_MockObject
364		*/
365		private function createPersisterRegistryStub($objectPersister = null)
366		{
367		$registryMock = $this->createPersisterRegistryMock();
368		$registryMock
369		->expects($this->once())
370		->method('getPersister')
371		->with('theIndex', 'theType')
372		->willReturn($objectPersister)
373		;
374
375		return $registryMock;
376		}
377		}

FriendsOfSymfony / FOSElasticaBundle

Pull Request — master (#1333)

testShouldDispatchOnExceptionEventWithExpectedArgumentsAndReThrowIt() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like