TrashServiceTest - Code Metrics - Inspection of "EZP-30616: Tests" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — ezp-30616 ( 8e069f...7bf8e8 )

unknown

created 2019-06-11 10:01 UTC

TrashServiceTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	398
Duplicated Lines	41.71 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
dl	166
loc	398
rs	10
c	0
b	0
f	0
wmc	12
lcom	1
cbo	7

12 Methods

Rating	Name	Duplication	Size	Complexity
A	testEmptyTrashEvents()	0	26	1
A	testReturnEmptyTrashResultInBeforeEvents()	32	32	1
A	testEmptyTrashStopPropagationInBeforeEvents()	35	35	1
A	testTrashEvents()	0	27	1
A	testReturnTrashResultInBeforeEvents()	0	33	1
A	testTrashStopPropagationInBeforeEvents()	0	36	1
A	testRecoverEvents()	28	28	1
A	testReturnRecoverResultInBeforeEvents()	34	34	1
A	testRecoverStopPropagationInBeforeEvents()	37	37	1
A	testDeleteTrashItemEvents()	0	27	1
A	testReturnDeleteTrashItemResultInBeforeEvents()	0	33	1
A	testDeleteTrashItemStopPropagationInBeforeEvents()	0	36	1

How to fix Duplicated Code

<?php

/**
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\Event\Tests;

use eZ\Publish\API\Repository\TrashService as TrashServiceInterface;
use eZ\Publish\API\Repository\Values\Content\Location;
use eZ\Publish\API\Repository\Values\Content\TrashItem;
use eZ\Publish\API\Repository\Values\Content\Trash\TrashItemDeleteResult;
use eZ\Publish\API\Repository\Values\Content\Trash\TrashItemDeleteResultList;
use eZ\Publish\Core\Event\TrashService;
use eZ\Publish\Core\Event\Trash\BeforeDeleteTrashItemEvent;
use eZ\Publish\Core\Event\Trash\BeforeEmptyTrashEvent;
use eZ\Publish\Core\Event\Trash\BeforeRecoverEvent;
use eZ\Publish\Core\Event\Trash\BeforeTrashEvent;
use eZ\Publish\Core\Event\Trash\TrashEvents;

class TrashServiceTest extends AbstractServiceTest
{
    public function testEmptyTrashEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_EMPTY_TRASH,
            TrashEvents::EMPTY_TRASH
        );

        $parameters = [
        ];

        $resultList = $this->createMock(TrashItemDeleteResultList::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('emptyTrash')->willReturn($resultList);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->emptyTrash(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($resultList, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_EMPTY_TRASH, 0],
            [TrashEvents::EMPTY_TRASH, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testReturnEmptyTrashResultInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_EMPTY_TRASH,
            TrashEvents::EMPTY_TRASH
        );

        $parameters = [
        ];

        $resultList = $this->createMock(TrashItemDeleteResultList::class);
        $eventResultList = $this->createMock(TrashItemDeleteResultList::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('emptyTrash')->willReturn($resultList);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_EMPTY_TRASH, function (BeforeEmptyTrashEvent $event) use ($eventResultList) {
            $event->setResultList($eventResultList);
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->emptyTrash(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($eventResultList, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_EMPTY_TRASH, 10],
            [TrashEvents::BEFORE_EMPTY_TRASH, 0],
            [TrashEvents::EMPTY_TRASH, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testEmptyTrashStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_EMPTY_TRASH,
            TrashEvents::EMPTY_TRASH
        );

        $parameters = [
        ];

        $resultList = $this->createMock(TrashItemDeleteResultList::class);
        $eventResultList = $this->createMock(TrashItemDeleteResultList::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('emptyTrash')->willReturn($resultList);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_EMPTY_TRASH, function (BeforeEmptyTrashEvent $event) use ($eventResultList) {
            $event->setResultList($eventResultList);
            $event->stopPropagation();
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->emptyTrash(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
        $notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());

        $this->assertSame($eventResultList, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_EMPTY_TRASH, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [TrashEvents::EMPTY_TRASH, 0],
            [TrashEvents::BEFORE_EMPTY_TRASH, 0],
        ]);
    }

    public function testTrashEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_TRASH,
            TrashEvents::TRASH
        );

        $parameters = [
            $this->createMock(Location::class),
        ];

        $trashItem = $this->createMock(TrashItem::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('trash')->willReturn($trashItem);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->trash(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($trashItem, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_TRASH, 0],
            [TrashEvents::TRASH, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testReturnTrashResultInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_TRASH,
            TrashEvents::TRASH
        );

        $parameters = [
            $this->createMock(Location::class),
        ];

        $trashItem = $this->createMock(TrashItem::class);
        $eventTrashItem = $this->createMock(TrashItem::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('trash')->willReturn($trashItem);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_TRASH, function (BeforeTrashEvent $event) use ($eventTrashItem) {
            $event->setResult($eventTrashItem);
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->trash(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($eventTrashItem, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_TRASH, 10],
            [TrashEvents::BEFORE_TRASH, 0],
            [TrashEvents::TRASH, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testTrashStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_TRASH,
            TrashEvents::TRASH
        );

        $parameters = [
            $this->createMock(Location::class),
        ];

        $trashItem = $this->createMock(TrashItem::class);
        $eventTrashItem = $this->createMock(TrashItem::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('trash')->willReturn($trashItem);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_TRASH, function (BeforeTrashEvent $event) use ($eventTrashItem) {
            $event->setResult($eventTrashItem);
            $event->stopPropagation();
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->trash(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
        $notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());

        $this->assertSame($eventTrashItem, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_TRASH, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [TrashEvents::TRASH, 0],
            [TrashEvents::BEFORE_TRASH, 0],
        ]);
    }

    public function testRecoverEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_RECOVER,
            TrashEvents::RECOVER
        );

        $parameters = [
            $this->createMock(TrashItem::class),
            $this->createMock(Location::class),
        ];

        $location = $this->createMock(Location::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('recover')->willReturn($location);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->recover(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($location, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_RECOVER, 0],
            [TrashEvents::RECOVER, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testReturnRecoverResultInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_RECOVER,
            TrashEvents::RECOVER
        );

        $parameters = [
            $this->createMock(TrashItem::class),
            $this->createMock(Location::class),
        ];

        $location = $this->createMock(Location::class);
        $eventLocation = $this->createMock(Location::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('recover')->willReturn($location);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_RECOVER, function (BeforeRecoverEvent $event) use ($eventLocation) {
            $event->setLocation($eventLocation);
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->recover(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($eventLocation, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_RECOVER, 10],
            [TrashEvents::BEFORE_RECOVER, 0],
            [TrashEvents::RECOVER, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testRecoverStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_RECOVER,
            TrashEvents::RECOVER
        );

        $parameters = [
            $this->createMock(TrashItem::class),
            $this->createMock(Location::class),
        ];

        $location = $this->createMock(Location::class);
        $eventLocation = $this->createMock(Location::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('recover')->willReturn($location);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_RECOVER, function (BeforeRecoverEvent $event) use ($eventLocation) {
            $event->setLocation($eventLocation);
            $event->stopPropagation();
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->recover(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
        $notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());

        $this->assertSame($eventLocation, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_RECOVER, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [TrashEvents::RECOVER, 0],
            [TrashEvents::BEFORE_RECOVER, 0],
        ]);
    }

    public function testDeleteTrashItemEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_DELETE_TRASH_ITEM,
            TrashEvents::DELETE_TRASH_ITEM
        );

        $parameters = [
            $this->createMock(TrashItem::class),
        ];

        $result = $this->createMock(TrashItemDeleteResult::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('deleteTrashItem')->willReturn($result);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->deleteTrashItem(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($result, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_DELETE_TRASH_ITEM, 0],
            [TrashEvents::DELETE_TRASH_ITEM, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testReturnDeleteTrashItemResultInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_DELETE_TRASH_ITEM,
            TrashEvents::DELETE_TRASH_ITEM
        );

        $parameters = [
            $this->createMock(TrashItem::class),
        ];

        $result = $this->createMock(TrashItemDeleteResult::class);
        $eventResult = $this->createMock(TrashItemDeleteResult::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('deleteTrashItem')->willReturn($result);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_DELETE_TRASH_ITEM, function (BeforeDeleteTrashItemEvent $event) use ($eventResult) {
            $event->setResult($eventResult);
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->deleteTrashItem(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());

        $this->assertSame($eventResult, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_DELETE_TRASH_ITEM, 10],
            [TrashEvents::BEFORE_DELETE_TRASH_ITEM, 0],
            [TrashEvents::DELETE_TRASH_ITEM, 0],
        ]);
        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testDeleteTrashItemStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            TrashEvents::BEFORE_DELETE_TRASH_ITEM,
            TrashEvents::DELETE_TRASH_ITEM
        );

        $parameters = [
            $this->createMock(TrashItem::class),
        ];

        $result = $this->createMock(TrashItemDeleteResult::class);
        $eventResult = $this->createMock(TrashItemDeleteResult::class);
        $innerServiceMock = $this->createMock(TrashServiceInterface::class);
        $innerServiceMock->method('deleteTrashItem')->willReturn($result);

        $traceableEventDispatcher->addListener(TrashEvents::BEFORE_DELETE_TRASH_ITEM, function (BeforeDeleteTrashItemEvent $event) use ($eventResult) {
            $event->setResult($eventResult);
            $event->stopPropagation();
        }, 10);

        $service = new TrashService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->deleteTrashItem(...$parameters);

        $calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
        $notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());

        $this->assertSame($eventResult, $result);
        $this->assertSame($calledListeners, [
            [TrashEvents::BEFORE_DELETE_TRASH_ITEM, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [TrashEvents::DELETE_TRASH_ITEM, 0],
            [TrashEvents::BEFORE_DELETE_TRASH_ITEM, 0],
        ]);
    }
}


1		<?php
2
3		/**
4		* @copyright Copyright (C) eZ Systems AS. All rights reserved.
5		* @license For full copyright and license information view LICENSE file distributed with this source code.
6		*/
7		namespace eZ\Publish\Core\Event\Tests;
8
9		use eZ\Publish\API\Repository\TrashService as TrashServiceInterface;
10		use eZ\Publish\API\Repository\Values\Content\Location;
11		use eZ\Publish\API\Repository\Values\Content\TrashItem;
12		use eZ\Publish\API\Repository\Values\Content\Trash\TrashItemDeleteResult;
13		use eZ\Publish\API\Repository\Values\Content\Trash\TrashItemDeleteResultList;
14		use eZ\Publish\Core\Event\TrashService;
15		use eZ\Publish\Core\Event\Trash\BeforeDeleteTrashItemEvent;
16		use eZ\Publish\Core\Event\Trash\BeforeEmptyTrashEvent;
17		use eZ\Publish\Core\Event\Trash\BeforeRecoverEvent;
18		use eZ\Publish\Core\Event\Trash\BeforeTrashEvent;
19		use eZ\Publish\Core\Event\Trash\TrashEvents;
20
21		class TrashServiceTest extends AbstractServiceTest
22		{
23		public function testEmptyTrashEvents()
24		{
25		$traceableEventDispatcher = $this->getEventDispatcher(
26		TrashEvents::BEFORE_EMPTY_TRASH,
27		TrashEvents::EMPTY_TRASH
28		);
29
30		$parameters = [
31		];
32
33		$resultList = $this->createMock(TrashItemDeleteResultList::class);
34		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
35		$innerServiceMock->method('emptyTrash')->willReturn($resultList);
36
37		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
38		$result = $service->emptyTrash(...$parameters);
39
40		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
41
42		$this->assertSame($resultList, $result);
43		$this->assertSame($calledListeners, [
44		[TrashEvents::BEFORE_EMPTY_TRASH, 0],
45		[TrashEvents::EMPTY_TRASH, 0],
46		]);
47		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
48		}
49
50	View Code Duplication	public function testReturnEmptyTrashResultInBeforeEvents()
51		{
52		$traceableEventDispatcher = $this->getEventDispatcher(
53		TrashEvents::BEFORE_EMPTY_TRASH,
54		TrashEvents::EMPTY_TRASH
55		);
56
57		$parameters = [
58		];
59
60		$resultList = $this->createMock(TrashItemDeleteResultList::class);
61		$eventResultList = $this->createMock(TrashItemDeleteResultList::class);
62		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
63		$innerServiceMock->method('emptyTrash')->willReturn($resultList);
64
65		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_EMPTY_TRASH, function (BeforeEmptyTrashEvent $event) use ($eventResultList) {
66		$event->setResultList($eventResultList);
67		}, 10);
68
69		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
70		$result = $service->emptyTrash(...$parameters);
71
72		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
73
74		$this->assertSame($eventResultList, $result);
75		$this->assertSame($calledListeners, [
76		[TrashEvents::BEFORE_EMPTY_TRASH, 10],
77		[TrashEvents::BEFORE_EMPTY_TRASH, 0],
78		[TrashEvents::EMPTY_TRASH, 0],
79		]);
80		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
81		}
82
83	View Code Duplication	public function testEmptyTrashStopPropagationInBeforeEvents()
84		{
85		$traceableEventDispatcher = $this->getEventDispatcher(
86		TrashEvents::BEFORE_EMPTY_TRASH,
87		TrashEvents::EMPTY_TRASH
88		);
89
90		$parameters = [
91		];
92
93		$resultList = $this->createMock(TrashItemDeleteResultList::class);
94		$eventResultList = $this->createMock(TrashItemDeleteResultList::class);
95		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
96		$innerServiceMock->method('emptyTrash')->willReturn($resultList);
97
98		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_EMPTY_TRASH, function (BeforeEmptyTrashEvent $event) use ($eventResultList) {
99		$event->setResultList($eventResultList);
100		$event->stopPropagation();
101		}, 10);
102
103		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
104		$result = $service->emptyTrash(...$parameters);
105
106		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
107		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
108
109		$this->assertSame($eventResultList, $result);
110		$this->assertSame($calledListeners, [
111		[TrashEvents::BEFORE_EMPTY_TRASH, 10],
112		]);
113		$this->assertSame($notCalledListeners, [
114		[TrashEvents::EMPTY_TRASH, 0],
115		[TrashEvents::BEFORE_EMPTY_TRASH, 0],
116		]);
117		}
118
119		public function testTrashEvents()
120		{
121		$traceableEventDispatcher = $this->getEventDispatcher(
122		TrashEvents::BEFORE_TRASH,
123		TrashEvents::TRASH
124		);
125
126		$parameters = [
127		$this->createMock(Location::class),
128		];
129
130		$trashItem = $this->createMock(TrashItem::class);
131		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
132		$innerServiceMock->method('trash')->willReturn($trashItem);
133
134		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
135		$result = $service->trash(...$parameters);
136
137		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
138
139		$this->assertSame($trashItem, $result);
140		$this->assertSame($calledListeners, [
141		[TrashEvents::BEFORE_TRASH, 0],
142		[TrashEvents::TRASH, 0],
143		]);
144		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
145		}
146
147		public function testReturnTrashResultInBeforeEvents()
148		{
149		$traceableEventDispatcher = $this->getEventDispatcher(
150		TrashEvents::BEFORE_TRASH,
151		TrashEvents::TRASH
152		);
153
154		$parameters = [
155		$this->createMock(Location::class),
156		];
157
158		$trashItem = $this->createMock(TrashItem::class);
159		$eventTrashItem = $this->createMock(TrashItem::class);
160		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
161		$innerServiceMock->method('trash')->willReturn($trashItem);
162
163		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_TRASH, function (BeforeTrashEvent $event) use ($eventTrashItem) {
164		$event->setResult($eventTrashItem);
165		}, 10);
166
167		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
168		$result = $service->trash(...$parameters);
169
170		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
171
172		$this->assertSame($eventTrashItem, $result);
173		$this->assertSame($calledListeners, [
174		[TrashEvents::BEFORE_TRASH, 10],
175		[TrashEvents::BEFORE_TRASH, 0],
176		[TrashEvents::TRASH, 0],
177		]);
178		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
179		}
180
181		public function testTrashStopPropagationInBeforeEvents()
182		{
183		$traceableEventDispatcher = $this->getEventDispatcher(
184		TrashEvents::BEFORE_TRASH,
185		TrashEvents::TRASH
186		);
187
188		$parameters = [
189		$this->createMock(Location::class),
190		];
191
192		$trashItem = $this->createMock(TrashItem::class);
193		$eventTrashItem = $this->createMock(TrashItem::class);
194		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
195		$innerServiceMock->method('trash')->willReturn($trashItem);
196
197		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_TRASH, function (BeforeTrashEvent $event) use ($eventTrashItem) {
198		$event->setResult($eventTrashItem);
199		$event->stopPropagation();
200		}, 10);
201
202		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
203		$result = $service->trash(...$parameters);
204
205		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
206		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
207
208		$this->assertSame($eventTrashItem, $result);
209		$this->assertSame($calledListeners, [
210		[TrashEvents::BEFORE_TRASH, 10],
211		]);
212		$this->assertSame($notCalledListeners, [
213		[TrashEvents::TRASH, 0],
214		[TrashEvents::BEFORE_TRASH, 0],
215		]);
216		}
217
218	View Code Duplication	public function testRecoverEvents()
219		{
220		$traceableEventDispatcher = $this->getEventDispatcher(
221		TrashEvents::BEFORE_RECOVER,
222		TrashEvents::RECOVER
223		);
224
225		$parameters = [
226		$this->createMock(TrashItem::class),
227		$this->createMock(Location::class),
228		];
229
230		$location = $this->createMock(Location::class);
231		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
232		$innerServiceMock->method('recover')->willReturn($location);
233
234		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
235		$result = $service->recover(...$parameters);
236
237		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
238
239		$this->assertSame($location, $result);
240		$this->assertSame($calledListeners, [
241		[TrashEvents::BEFORE_RECOVER, 0],
242		[TrashEvents::RECOVER, 0],
243		]);
244		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
245		}
246
247	View Code Duplication	public function testReturnRecoverResultInBeforeEvents()
248		{
249		$traceableEventDispatcher = $this->getEventDispatcher(
250		TrashEvents::BEFORE_RECOVER,
251		TrashEvents::RECOVER
252		);
253
254		$parameters = [
255		$this->createMock(TrashItem::class),
256		$this->createMock(Location::class),
257		];
258
259		$location = $this->createMock(Location::class);
260		$eventLocation = $this->createMock(Location::class);
261		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
262		$innerServiceMock->method('recover')->willReturn($location);
263
264		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_RECOVER, function (BeforeRecoverEvent $event) use ($eventLocation) {
265		$event->setLocation($eventLocation);
266		}, 10);
267
268		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
269		$result = $service->recover(...$parameters);
270
271		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
272
273		$this->assertSame($eventLocation, $result);
274		$this->assertSame($calledListeners, [
275		[TrashEvents::BEFORE_RECOVER, 10],
276		[TrashEvents::BEFORE_RECOVER, 0],
277		[TrashEvents::RECOVER, 0],
278		]);
279		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
280		}
281
282	View Code Duplication	public function testRecoverStopPropagationInBeforeEvents()
283		{
284		$traceableEventDispatcher = $this->getEventDispatcher(
285		TrashEvents::BEFORE_RECOVER,
286		TrashEvents::RECOVER
287		);
288
289		$parameters = [
290		$this->createMock(TrashItem::class),
291		$this->createMock(Location::class),
292		];
293
294		$location = $this->createMock(Location::class);
295		$eventLocation = $this->createMock(Location::class);
296		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
297		$innerServiceMock->method('recover')->willReturn($location);
298
299		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_RECOVER, function (BeforeRecoverEvent $event) use ($eventLocation) {
300		$event->setLocation($eventLocation);
301		$event->stopPropagation();
302		}, 10);
303
304		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
305		$result = $service->recover(...$parameters);
306
307		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
308		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
309
310		$this->assertSame($eventLocation, $result);
311		$this->assertSame($calledListeners, [
312		[TrashEvents::BEFORE_RECOVER, 10],
313		]);
314		$this->assertSame($notCalledListeners, [
315		[TrashEvents::RECOVER, 0],
316		[TrashEvents::BEFORE_RECOVER, 0],
317		]);
318		}
319
320		public function testDeleteTrashItemEvents()
321		{
322		$traceableEventDispatcher = $this->getEventDispatcher(
323		TrashEvents::BEFORE_DELETE_TRASH_ITEM,
324		TrashEvents::DELETE_TRASH_ITEM
325		);
326
327		$parameters = [
328		$this->createMock(TrashItem::class),
329		];
330
331		$result = $this->createMock(TrashItemDeleteResult::class);
332		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
333		$innerServiceMock->method('deleteTrashItem')->willReturn($result);
334
335		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
336		$result = $service->deleteTrashItem(...$parameters);
337
338		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
339
340		$this->assertSame($result, $result);
341		$this->assertSame($calledListeners, [
342		[TrashEvents::BEFORE_DELETE_TRASH_ITEM, 0],
343		[TrashEvents::DELETE_TRASH_ITEM, 0],
344		]);
345		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
346		}
347
348		public function testReturnDeleteTrashItemResultInBeforeEvents()
349		{
350		$traceableEventDispatcher = $this->getEventDispatcher(
351		TrashEvents::BEFORE_DELETE_TRASH_ITEM,
352		TrashEvents::DELETE_TRASH_ITEM
353		);
354
355		$parameters = [
356		$this->createMock(TrashItem::class),
357		];
358
359		$result = $this->createMock(TrashItemDeleteResult::class);
360		$eventResult = $this->createMock(TrashItemDeleteResult::class);
361		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
362		$innerServiceMock->method('deleteTrashItem')->willReturn($result);
363
364		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_DELETE_TRASH_ITEM, function (BeforeDeleteTrashItemEvent $event) use ($eventResult) {
365		$event->setResult($eventResult);
366		}, 10);
367
368		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
369		$result = $service->deleteTrashItem(...$parameters);
370
371		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
372
373		$this->assertSame($eventResult, $result);
374		$this->assertSame($calledListeners, [
375		[TrashEvents::BEFORE_DELETE_TRASH_ITEM, 10],
376		[TrashEvents::BEFORE_DELETE_TRASH_ITEM, 0],
377		[TrashEvents::DELETE_TRASH_ITEM, 0],
378		]);
379		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
380		}
381
382		public function testDeleteTrashItemStopPropagationInBeforeEvents()
383		{
384		$traceableEventDispatcher = $this->getEventDispatcher(
385		TrashEvents::BEFORE_DELETE_TRASH_ITEM,
386		TrashEvents::DELETE_TRASH_ITEM
387		);
388
389		$parameters = [
390		$this->createMock(TrashItem::class),
391		];
392
393		$result = $this->createMock(TrashItemDeleteResult::class);
394		$eventResult = $this->createMock(TrashItemDeleteResult::class);
395		$innerServiceMock = $this->createMock(TrashServiceInterface::class);
396		$innerServiceMock->method('deleteTrashItem')->willReturn($result);
397
398		$traceableEventDispatcher->addListener(TrashEvents::BEFORE_DELETE_TRASH_ITEM, function (BeforeDeleteTrashItemEvent $event) use ($eventResult) {
399		$event->setResult($eventResult);
400		$event->stopPropagation();
401		}, 10);
402
403		$service = new TrashService($innerServiceMock, $traceableEventDispatcher);
404		$result = $service->deleteTrashItem(...$parameters);
405
406		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
407		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
408
409		$this->assertSame($eventResult, $result);
410		$this->assertSame($calledListeners, [
411		[TrashEvents::BEFORE_DELETE_TRASH_ITEM, 10],
412		]);
413		$this->assertSame($notCalledListeners, [
414		[TrashEvents::DELETE_TRASH_ITEM, 0],
415		[TrashEvents::BEFORE_DELETE_TRASH_ITEM, 0],
416		]);
417		}
418		}
419

ezsystems / ezpublish-kernel

Push — ezp-30616 ( 8e069f...7bf8e8 )

TrashServiceTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like