Code Duplication - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 32-33 lines in 18 locations

eZ/Publish/Core/Event/Tests/ContentServiceTest.php 1 location


        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testDeleteRelationStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeDeleteRelationEvent::class,
            DeleteRelationEvent::class
        );

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

        $innerServiceMock = $this->createMock(ContentServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeDeleteRelationEvent::class, function (BeforeDeleteRelationEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentService($innerServiceMock, $traceableEventDispatcher);
        $service->deleteRelation(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeDeleteRelationEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeDeleteRelationEvent::class, 0],
            [DeleteRelationEvent::class, 0],
        ]);
    }

    public function testCreateContentEvents()
    {

eZ/Publish/Core/Event/Tests/ContentTypeServiceTest.php 7 locations


        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testAddFieldDefinitionStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeAddFieldDefinitionEvent::class,
            AddFieldDefinitionEvent::class
        );

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

        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeAddFieldDefinitionEvent::class, function (BeforeAddFieldDefinitionEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
        $service->addFieldDefinition(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeAddFieldDefinitionEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [AddFieldDefinitionEvent::class, 0],
            [BeforeAddFieldDefinitionEvent::class, 0],
        ]);
    }

    public function testDeleteContentTypeGroupEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testUpdateContentTypeGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeUpdateContentTypeGroupEvent::class,
            UpdateContentTypeGroupEvent::class
        );

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

        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeUpdateContentTypeGroupEvent::class, function (BeforeUpdateContentTypeGroupEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
        $service->updateContentTypeGroup(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeUpdateContentTypeGroupEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeUpdateContentTypeGroupEvent::class, 0],
            [UpdateContentTypeGroupEvent::class, 0],
        ]);
    }

    public function testCreateContentTypeEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testUnassignContentTypeGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeUnassignContentTypeGroupEvent::class,
            UnassignContentTypeGroupEvent::class
        );

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

        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeUnassignContentTypeGroupEvent::class, function (BeforeUnassignContentTypeGroupEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
        $service->unassignContentTypeGroup(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeUnassignContentTypeGroupEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeUnassignContentTypeGroupEvent::class, 0],
            [UnassignContentTypeGroupEvent::class, 0],
        ]);
    }

    public function testPublishContentTypeDraftEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testUpdateFieldDefinitionStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeUpdateFieldDefinitionEvent::class,
            UpdateFieldDefinitionEvent::class
        );

        $parameters = [
            $this->createMock(ContentTypeDraft::class),
            $this->createMock(FieldDefinition::class),
            $this->createMock(FieldDefinitionUpdateStruct::class),
        ];

        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeUpdateFieldDefinitionEvent::class, function (BeforeUpdateFieldDefinitionEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
        $service->updateFieldDefinition(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeUpdateFieldDefinitionEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeUpdateFieldDefinitionEvent::class, 0],
            [UpdateFieldDefinitionEvent::class, 0],
        ]);
    }

    public function testRemoveFieldDefinitionEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testRemoveFieldDefinitionStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeRemoveFieldDefinitionEvent::class,
            RemoveFieldDefinitionEvent::class
        );

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

        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeRemoveFieldDefinitionEvent::class, function (BeforeRemoveFieldDefinitionEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
        $service->removeFieldDefinition(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeRemoveFieldDefinitionEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeRemoveFieldDefinitionEvent::class, 0],
            [RemoveFieldDefinitionEvent::class, 0],
        ]);
    }

    public function testAssignContentTypeGroupEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testAssignContentTypeGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeAssignContentTypeGroupEvent::class,
            AssignContentTypeGroupEvent::class
        );

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

        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeAssignContentTypeGroupEvent::class, function (BeforeAssignContentTypeGroupEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
        $service->assignContentTypeGroup(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeAssignContentTypeGroupEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [AssignContentTypeGroupEvent::class, 0],
            [BeforeAssignContentTypeGroupEvent::class, 0],
        ]);
    }

    public function testUpdateContentTypeDraftEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testUpdateContentTypeDraftStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeUpdateContentTypeDraftEvent::class,
            UpdateContentTypeDraftEvent::class
        );

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

        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeUpdateContentTypeDraftEvent::class, function (BeforeUpdateContentTypeDraftEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
        $service->updateContentTypeDraft(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeUpdateContentTypeDraftEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeUpdateContentTypeDraftEvent::class, 0],
            [UpdateContentTypeDraftEvent::class, 0],
        ]);
    }

    public function testDeleteContentTypeEvents()
    {

eZ/Publish/Core/Event/Tests/LocationServiceTest.php 2 locations


        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testSwapLocationStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeSwapLocationEvent::class,
            SwapLocationEvent::class
        );

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

        $innerServiceMock = $this->createMock(LocationServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeSwapLocationEvent::class, function (BeforeSwapLocationEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new LocationService($innerServiceMock, $traceableEventDispatcher);
        $service->swapLocation(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeSwapLocationEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeSwapLocationEvent::class, 0],
            [SwapLocationEvent::class, 0],
        ]);
    }

    public function testMoveSubtreeEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testMoveSubtreeStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeMoveSubtreeEvent::class,
            MoveSubtreeEvent::class
        );

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

        $innerServiceMock = $this->createMock(LocationServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeMoveSubtreeEvent::class, function (BeforeMoveSubtreeEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new LocationService($innerServiceMock, $traceableEventDispatcher);
        $service->moveSubtree(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeMoveSubtreeEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeMoveSubtreeEvent::class, 0],
            [MoveSubtreeEvent::class, 0],
        ]);
    }

    public function testUpdateLocationEvents()
    {

eZ/Publish/Core/Event/Tests/ObjectStateServiceTest.php 1 location


        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testSetContentStateStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeSetContentStateEvent::class,
            SetContentStateEvent::class
        );

        $parameters = [
            $this->createMock(ContentInfo::class),
            $this->createMock(ObjectStateGroup::class),
            $this->createMock(ObjectState::class),
        ];

        $innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeSetContentStateEvent::class, function (BeforeSetContentStateEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new ObjectStateService($innerServiceMock, $traceableEventDispatcher);
        $service->setContentState(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeSetContentStateEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeSetContentStateEvent::class, 0],
            [SetContentStateEvent::class, 0],
        ]);
    }

    public function testCreateObjectStateGroupEvents()
    {

eZ/Publish/Core/Event/Tests/RoleServiceTest.php 2 locations


        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testAssignRoleToUserStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeAssignRoleToUserEvent::class,
            AssignRoleToUserEvent::class
        );

        $parameters = [
            $this->createMock(Role::class),
            $this->createMock(User::class),
            $this->createMock(RoleLimitation::class),
        ];

        $innerServiceMock = $this->createMock(RoleServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeAssignRoleToUserEvent::class, function (BeforeAssignRoleToUserEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new RoleService($innerServiceMock, $traceableEventDispatcher);
        $service->assignRoleToUser(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeAssignRoleToUserEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [AssignRoleToUserEvent::class, 0],
            [BeforeAssignRoleToUserEvent::class, 0],
        ]);
    }

    public function testUpdateRoleDraftEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testAssignRoleToUserGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeAssignRoleToUserGroupEvent::class,
            AssignRoleToUserGroupEvent::class
        );

        $parameters = [
            $this->createMock(Role::class),
            $this->createMock(UserGroup::class),
            $this->createMock(RoleLimitation::class),
        ];

        $innerServiceMock = $this->createMock(RoleServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeAssignRoleToUserGroupEvent::class, function (BeforeAssignRoleToUserGroupEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new RoleService($innerServiceMock, $traceableEventDispatcher);
        $service->assignRoleToUserGroup(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeAssignRoleToUserGroupEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [AssignRoleToUserGroupEvent::class, 0],
            [BeforeAssignRoleToUserGroupEvent::class, 0],
        ]);
    }

    public function testUpdatePolicyByRoleDraftEvents()
    {

eZ/Publish/Core/Event/Tests/SectionServiceTest.php 2 locations


        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testAssignSectionStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeAssignSectionEvent::class,
            AssignSectionEvent::class
        );

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

        $innerServiceMock = $this->createMock(SectionServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeAssignSectionEvent::class, function (BeforeAssignSectionEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new SectionService($innerServiceMock, $traceableEventDispatcher);
        $service->assignSection(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeAssignSectionEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [AssignSectionEvent::class, 0],
            [BeforeAssignSectionEvent::class, 0],
        ]);
    }

    public function testUpdateSectionEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testAssignSectionToSubtreeStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeAssignSectionToSubtreeEvent::class,
            AssignSectionToSubtreeEvent::class
        );

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

        $innerServiceMock = $this->createMock(SectionServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeAssignSectionToSubtreeEvent::class, function (BeforeAssignSectionToSubtreeEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new SectionService($innerServiceMock, $traceableEventDispatcher);
        $service->assignSectionToSubtree(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeAssignSectionToSubtreeEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [AssignSectionToSubtreeEvent::class, 0],
            [BeforeAssignSectionToSubtreeEvent::class, 0],
        ]);
    }

    public function testDeleteSectionEvents()
    {

eZ/Publish/Core/Event/Tests/UserServiceTest.php 3 locations


        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testUnAssignUserFromUserGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeUnAssignUserFromUserGroupEvent::class,
            UnAssignUserFromUserGroupEvent::class
        );

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

        $innerServiceMock = $this->createMock(UserServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeUnAssignUserFromUserGroupEvent::class, function (BeforeUnAssignUserFromUserGroupEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new UserService($innerServiceMock, $traceableEventDispatcher);
        $service->unAssignUserFromUserGroup(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeUnAssignUserFromUserGroupEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeUnAssignUserFromUserGroupEvent::class, 0],
            [UnAssignUserFromUserGroupEvent::class, 0],
        ]);
    }

    public function testDeleteUserGroupEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testAssignUserToUserGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeAssignUserToUserGroupEvent::class,
            AssignUserToUserGroupEvent::class
        );

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

        $innerServiceMock = $this->createMock(UserServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeAssignUserToUserGroupEvent::class, function (BeforeAssignUserToUserGroupEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new UserService($innerServiceMock, $traceableEventDispatcher);
        $service->assignUserToUserGroup(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeAssignUserToUserGroupEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [AssignUserToUserGroupEvent::class, 0],
            [BeforeAssignUserToUserGroupEvent::class, 0],
        ]);
    }

    public function testDeleteUserEvents()
    {

        $this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
    }

    public function testMoveUserGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            BeforeMoveUserGroupEvent::class,
            MoveUserGroupEvent::class
        );

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

        $innerServiceMock = $this->createMock(UserServiceInterface::class);

        $traceableEventDispatcher->addListener(BeforeMoveUserGroupEvent::class, function (BeforeMoveUserGroupEvent $event) {
            $event->stopPropagation();
        }, 10);

        $service = new UserService($innerServiceMock, $traceableEventDispatcher);
        $service->moveUserGroup(...$parameters);

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

        $this->assertSame($calledListeners, [
            [BeforeMoveUserGroupEvent::class, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [BeforeMoveUserGroupEvent::class, 0],
            [MoveUserGroupEvent::class, 0],
        ]);
    }

    public function testCreateUserEvents()
    {

		@@ 381-412 (lines=32) @@
378		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
379		}
380
381		public function testDeleteRelationStopPropagationInBeforeEvents()
382		{
383		$traceableEventDispatcher = $this->getEventDispatcher(
384		BeforeDeleteRelationEvent::class,
385		DeleteRelationEvent::class
386		);
387
388		$parameters = [
389		$this->createMock(VersionInfo::class),
390		$this->createMock(ContentInfo::class),
391		];
392
393		$innerServiceMock = $this->createMock(ContentServiceInterface::class);
394
395		$traceableEventDispatcher->addListener(BeforeDeleteRelationEvent::class, function (BeforeDeleteRelationEvent $event) {
396		$event->stopPropagation();
397		}, 10);
398
399		$service = new ContentService($innerServiceMock, $traceableEventDispatcher);
400		$service->deleteRelation(...$parameters);
401
402		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
403		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
404
405		$this->assertSame($calledListeners, [
406		[BeforeDeleteRelationEvent::class, 10],
407		]);
408		$this->assertSame($notCalledListeners, [
409		[BeforeDeleteRelationEvent::class, 0],
410		[DeleteRelationEvent::class, 0],
411		]);
412		}
413
414		public function testCreateContentEvents()
415		{

		@@ 417-448 (lines=32) @@
414		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
415		}
416
417		public function testSwapLocationStopPropagationInBeforeEvents()
418		{
419		$traceableEventDispatcher = $this->getEventDispatcher(
420		BeforeSwapLocationEvent::class,
421		SwapLocationEvent::class
422		);
423
424		$parameters = [
425		$this->createMock(Location::class),
426		$this->createMock(Location::class),
427		];
428
429		$innerServiceMock = $this->createMock(LocationServiceInterface::class);
430
431		$traceableEventDispatcher->addListener(BeforeSwapLocationEvent::class, function (BeforeSwapLocationEvent $event) {
432		$event->stopPropagation();
433		}, 10);
434
435		$service = new LocationService($innerServiceMock, $traceableEventDispatcher);
436		$service->swapLocation(...$parameters);
437
438		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
439		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
440
441		$this->assertSame($calledListeners, [
442		[BeforeSwapLocationEvent::class, 10],
443		]);
444		$this->assertSame($notCalledListeners, [
445		[BeforeSwapLocationEvent::class, 0],
446		[SwapLocationEvent::class, 0],
447		]);
448		}
449
450		public function testMoveSubtreeEvents()
451		{
		@@ 476-507 (lines=32) @@
473		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
474		}
475
476		public function testMoveSubtreeStopPropagationInBeforeEvents()
477		{
478		$traceableEventDispatcher = $this->getEventDispatcher(
479		BeforeMoveSubtreeEvent::class,
480		MoveSubtreeEvent::class
481		);
482
483		$parameters = [
484		$this->createMock(Location::class),
485		$this->createMock(Location::class),
486		];
487
488		$innerServiceMock = $this->createMock(LocationServiceInterface::class);
489
490		$traceableEventDispatcher->addListener(BeforeMoveSubtreeEvent::class, function (BeforeMoveSubtreeEvent $event) {
491		$event->stopPropagation();
492		}, 10);
493
494		$service = new LocationService($innerServiceMock, $traceableEventDispatcher);
495		$service->moveSubtree(...$parameters);
496
497		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
498		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
499
500		$this->assertSame($calledListeners, [
501		[BeforeMoveSubtreeEvent::class, 10],
502		]);
503		$this->assertSame($notCalledListeners, [
504		[BeforeMoveSubtreeEvent::class, 0],
505		[MoveSubtreeEvent::class, 0],
506		]);
507		}
508
509		public function testUpdateLocationEvents()
510		{

		@@ 64-96 (lines=33) @@
61		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
62		}
63
64		public function testSetContentStateStopPropagationInBeforeEvents()
65		{
66		$traceableEventDispatcher = $this->getEventDispatcher(
67		BeforeSetContentStateEvent::class,
68		SetContentStateEvent::class
69		);
70
71		$parameters = [
72		$this->createMock(ContentInfo::class),
73		$this->createMock(ObjectStateGroup::class),
74		$this->createMock(ObjectState::class),
75		];
76
77		$innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);
78
79		$traceableEventDispatcher->addListener(BeforeSetContentStateEvent::class, function (BeforeSetContentStateEvent $event) {
80		$event->stopPropagation();
81		}, 10);
82
83		$service = new ObjectStateService($innerServiceMock, $traceableEventDispatcher);
84		$service->setContentState(...$parameters);
85
86		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
87		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
88
89		$this->assertSame($calledListeners, [
90		[BeforeSetContentStateEvent::class, 10],
91		]);
92		$this->assertSame($notCalledListeners, [
93		[BeforeSetContentStateEvent::class, 0],
94		[SetContentStateEvent::class, 0],
95		]);
96		}
97
98		public function testCreateObjectStateGroupEvents()
99		{

		@@ 133-165 (lines=33) @@
130		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
131		}
132
133		public function testAssignRoleToUserStopPropagationInBeforeEvents()
134		{
135		$traceableEventDispatcher = $this->getEventDispatcher(
136		BeforeAssignRoleToUserEvent::class,
137		AssignRoleToUserEvent::class
138		);
139
140		$parameters = [
141		$this->createMock(Role::class),
142		$this->createMock(User::class),
143		$this->createMock(RoleLimitation::class),
144		];
145
146		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
147
148		$traceableEventDispatcher->addListener(BeforeAssignRoleToUserEvent::class, function (BeforeAssignRoleToUserEvent $event) {
149		$event->stopPropagation();
150		}, 10);
151
152		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
153		$service->assignRoleToUser(...$parameters);
154
155		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
156		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
157
158		$this->assertSame($calledListeners, [
159		[BeforeAssignRoleToUserEvent::class, 10],
160		]);
161		$this->assertSame($notCalledListeners, [
162		[AssignRoleToUserEvent::class, 0],
163		[BeforeAssignRoleToUserEvent::class, 0],
164		]);
165		}
166
167		public function testUpdateRoleDraftEvents()
168		{
		@@ 296-328 (lines=33) @@
293		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
294		}
295
296		public function testAssignRoleToUserGroupStopPropagationInBeforeEvents()
297		{
298		$traceableEventDispatcher = $this->getEventDispatcher(
299		BeforeAssignRoleToUserGroupEvent::class,
300		AssignRoleToUserGroupEvent::class
301		);
302
303		$parameters = [
304		$this->createMock(Role::class),
305		$this->createMock(UserGroup::class),
306		$this->createMock(RoleLimitation::class),
307		];
308
309		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
310
311		$traceableEventDispatcher->addListener(BeforeAssignRoleToUserGroupEvent::class, function (BeforeAssignRoleToUserGroupEvent $event) {
312		$event->stopPropagation();
313		}, 10);
314
315		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
316		$service->assignRoleToUserGroup(...$parameters);
317
318		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
319		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
320
321		$this->assertSame($calledListeners, [
322		[BeforeAssignRoleToUserGroupEvent::class, 10],
323		]);
324		$this->assertSame($notCalledListeners, [
325		[AssignRoleToUserGroupEvent::class, 0],
326		[BeforeAssignRoleToUserGroupEvent::class, 0],
327		]);
328		}
329
330		public function testUpdatePolicyByRoleDraftEvents()
331		{

		@@ 55-86 (lines=32) @@
52		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
53		}
54
55		public function testAssignSectionStopPropagationInBeforeEvents()
56		{
57		$traceableEventDispatcher = $this->getEventDispatcher(
58		BeforeAssignSectionEvent::class,
59		AssignSectionEvent::class
60		);
61
62		$parameters = [
63		$this->createMock(ContentInfo::class),
64		$this->createMock(Section::class),
65		];
66
67		$innerServiceMock = $this->createMock(SectionServiceInterface::class);
68
69		$traceableEventDispatcher->addListener(BeforeAssignSectionEvent::class, function (BeforeAssignSectionEvent $event) {
70		$event->stopPropagation();
71		}, 10);
72
73		$service = new SectionService($innerServiceMock, $traceableEventDispatcher);
74		$service->assignSection(...$parameters);
75
76		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
77		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
78
79		$this->assertSame($calledListeners, [
80		[BeforeAssignSectionEvent::class, 10],
81		]);
82		$this->assertSame($notCalledListeners, [
83		[AssignSectionEvent::class, 0],
84		[BeforeAssignSectionEvent::class, 0],
85		]);
86		}
87
88		public function testUpdateSectionEvents()
89		{
		@@ 216-247 (lines=32) @@
213		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
214		}
215
216		public function testAssignSectionToSubtreeStopPropagationInBeforeEvents()
217		{
218		$traceableEventDispatcher = $this->getEventDispatcher(
219		BeforeAssignSectionToSubtreeEvent::class,
220		AssignSectionToSubtreeEvent::class
221		);
222
223		$parameters = [
224		$this->createMock(Location::class),
225		$this->createMock(Section::class),
226		];
227
228		$innerServiceMock = $this->createMock(SectionServiceInterface::class);
229
230		$traceableEventDispatcher->addListener(BeforeAssignSectionToSubtreeEvent::class, function (BeforeAssignSectionToSubtreeEvent $event) {
231		$event->stopPropagation();
232		}, 10);
233
234		$service = new SectionService($innerServiceMock, $traceableEventDispatcher);
235		$service->assignSectionToSubtree(...$parameters);
236
237		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
238		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
239
240		$this->assertSame($calledListeners, [
241		[BeforeAssignSectionToSubtreeEvent::class, 10],
242		]);
243		$this->assertSame($notCalledListeners, [
244		[AssignSectionToSubtreeEvent::class, 0],
245		[BeforeAssignSectionToSubtreeEvent::class, 0],
246		]);
247		}
248
249		public function testDeleteSectionEvents()
250		{

		@@ 81-112 (lines=32) @@
78		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
79		}
80
81		public function testAddFieldDefinitionStopPropagationInBeforeEvents()
82		{
83		$traceableEventDispatcher = $this->getEventDispatcher(
84		BeforeAddFieldDefinitionEvent::class,
85		AddFieldDefinitionEvent::class
86		);
87
88		$parameters = [
89		$this->createMock(ContentTypeDraft::class),
90		$this->createMock(FieldDefinitionCreateStruct::class),
91		];
92
93		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
94
95		$traceableEventDispatcher->addListener(BeforeAddFieldDefinitionEvent::class, function (BeforeAddFieldDefinitionEvent $event) {
96		$event->stopPropagation();
97		}, 10);
98
99		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
100		$service->addFieldDefinition(...$parameters);
101
102		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
103		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
104
105		$this->assertSame($calledListeners, [
106		[BeforeAddFieldDefinitionEvent::class, 10],
107		]);
108		$this->assertSame($notCalledListeners, [
109		[AddFieldDefinitionEvent::class, 0],
110		[BeforeAddFieldDefinitionEvent::class, 0],
111		]);
112		}
113
114		public function testDeleteContentTypeGroupEvents()
115		{
		@@ 395-426 (lines=32) @@
392		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
393		}
394
395		public function testUpdateContentTypeGroupStopPropagationInBeforeEvents()
396		{
397		$traceableEventDispatcher = $this->getEventDispatcher(
398		BeforeUpdateContentTypeGroupEvent::class,
399		UpdateContentTypeGroupEvent::class
400		);
401
402		$parameters = [
403		$this->createMock(ContentTypeGroup::class),
404		$this->createMock(ContentTypeGroupUpdateStruct::class),
405		];
406
407		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
408
409		$traceableEventDispatcher->addListener(BeforeUpdateContentTypeGroupEvent::class, function (BeforeUpdateContentTypeGroupEvent $event) {
410		$event->stopPropagation();
411		}, 10);
412
413		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
414		$service->updateContentTypeGroup(...$parameters);
415
416		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
417		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
418
419		$this->assertSame($calledListeners, [
420		[BeforeUpdateContentTypeGroupEvent::class, 10],
421		]);
422		$this->assertSame($notCalledListeners, [
423		[BeforeUpdateContentTypeGroupEvent::class, 0],
424		[UpdateContentTypeGroupEvent::class, 0],
425		]);
426		}
427
428		public function testCreateContentTypeEvents()
429		{
		@@ 658-689 (lines=32) @@
655		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
656		}
657
658		public function testUnassignContentTypeGroupStopPropagationInBeforeEvents()
659		{
660		$traceableEventDispatcher = $this->getEventDispatcher(
661		BeforeUnassignContentTypeGroupEvent::class,
662		UnassignContentTypeGroupEvent::class
663		);
664
665		$parameters = [
666		$this->createMock(ContentType::class),
667		$this->createMock(ContentTypeGroup::class),
668		];
669
670		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
671
672		$traceableEventDispatcher->addListener(BeforeUnassignContentTypeGroupEvent::class, function (BeforeUnassignContentTypeGroupEvent $event) {
673		$event->stopPropagation();
674		}, 10);
675
676		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
677		$service->unassignContentTypeGroup(...$parameters);
678
679		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
680		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
681
682		$this->assertSame($calledListeners, [
683		[BeforeUnassignContentTypeGroupEvent::class, 10],
684		]);
685		$this->assertSame($notCalledListeners, [
686		[BeforeUnassignContentTypeGroupEvent::class, 0],
687		[UnassignContentTypeGroupEvent::class, 0],
688		]);
689		}
690
691		public function testPublishContentTypeDraftEvents()
692		{
		@@ 775-807 (lines=33) @@
772		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
773		}
774
775		public function testUpdateFieldDefinitionStopPropagationInBeforeEvents()
776		{
777		$traceableEventDispatcher = $this->getEventDispatcher(
778		BeforeUpdateFieldDefinitionEvent::class,
779		UpdateFieldDefinitionEvent::class
780		);
781
782		$parameters = [
783		$this->createMock(ContentTypeDraft::class),
784		$this->createMock(FieldDefinition::class),
785		$this->createMock(FieldDefinitionUpdateStruct::class),
786		];
787
788		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
789
790		$traceableEventDispatcher->addListener(BeforeUpdateFieldDefinitionEvent::class, function (BeforeUpdateFieldDefinitionEvent $event) {
791		$event->stopPropagation();
792		}, 10);
793
794		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
795		$service->updateFieldDefinition(...$parameters);
796
797		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
798		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
799
800		$this->assertSame($calledListeners, [
801		[BeforeUpdateFieldDefinitionEvent::class, 10],
802		]);
803		$this->assertSame($notCalledListeners, [
804		[BeforeUpdateFieldDefinitionEvent::class, 0],
805		[UpdateFieldDefinitionEvent::class, 0],
806		]);
807		}
808
809		public function testRemoveFieldDefinitionEvents()
810		{
		@@ 835-866 (lines=32) @@
832		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
833		}
834
835		public function testRemoveFieldDefinitionStopPropagationInBeforeEvents()
836		{
837		$traceableEventDispatcher = $this->getEventDispatcher(
838		BeforeRemoveFieldDefinitionEvent::class,
839		RemoveFieldDefinitionEvent::class
840		);
841
842		$parameters = [
843		$this->createMock(ContentTypeDraft::class),
844		$this->createMock(FieldDefinition::class),
845		];
846
847		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
848
849		$traceableEventDispatcher->addListener(BeforeRemoveFieldDefinitionEvent::class, function (BeforeRemoveFieldDefinitionEvent $event) {
850		$event->stopPropagation();
851		}, 10);
852
853		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
854		$service->removeFieldDefinition(...$parameters);
855
856		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
857		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
858
859		$this->assertSame($calledListeners, [
860		[BeforeRemoveFieldDefinitionEvent::class, 10],
861		]);
862		$this->assertSame($notCalledListeners, [
863		[BeforeRemoveFieldDefinitionEvent::class, 0],
864		[RemoveFieldDefinitionEvent::class, 0],
865		]);
866		}
867
868		public function testAssignContentTypeGroupEvents()
869		{
		@@ 894-925 (lines=32) @@
891		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
892		}
893
894		public function testAssignContentTypeGroupStopPropagationInBeforeEvents()
895		{
896		$traceableEventDispatcher = $this->getEventDispatcher(
897		BeforeAssignContentTypeGroupEvent::class,
898		AssignContentTypeGroupEvent::class
899		);
900
901		$parameters = [
902		$this->createMock(ContentType::class),
903		$this->createMock(ContentTypeGroup::class),
904		];
905
906		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
907
908		$traceableEventDispatcher->addListener(BeforeAssignContentTypeGroupEvent::class, function (BeforeAssignContentTypeGroupEvent $event) {
909		$event->stopPropagation();
910		}, 10);
911
912		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
913		$service->assignContentTypeGroup(...$parameters);
914
915		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
916		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
917
918		$this->assertSame($calledListeners, [
919		[BeforeAssignContentTypeGroupEvent::class, 10],
920		]);
921		$this->assertSame($notCalledListeners, [
922		[AssignContentTypeGroupEvent::class, 0],
923		[BeforeAssignContentTypeGroupEvent::class, 0],
924		]);
925		}
926
927		public function testUpdateContentTypeDraftEvents()
928		{
		@@ 953-984 (lines=32) @@
950		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
951		}
952
953		public function testUpdateContentTypeDraftStopPropagationInBeforeEvents()
954		{
955		$traceableEventDispatcher = $this->getEventDispatcher(
956		BeforeUpdateContentTypeDraftEvent::class,
957		UpdateContentTypeDraftEvent::class
958		);
959
960		$parameters = [
961		$this->createMock(ContentTypeDraft::class),
962		$this->createMock(ContentTypeUpdateStruct::class),
963		];
964
965		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
966
967		$traceableEventDispatcher->addListener(BeforeUpdateContentTypeDraftEvent::class, function (BeforeUpdateContentTypeDraftEvent $event) {
968		$event->stopPropagation();
969		}, 10);
970
971		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
972		$service->updateContentTypeDraft(...$parameters);
973
974		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
975		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
976
977		$this->assertSame($calledListeners, [
978		[BeforeUpdateContentTypeDraftEvent::class, 10],
979		]);
980		$this->assertSame($notCalledListeners, [
981		[BeforeUpdateContentTypeDraftEvent::class, 0],
982		[UpdateContentTypeDraftEvent::class, 0],
983		]);
984		}
985
986		public function testDeleteContentTypeEvents()
987		{

		@@ 271-302 (lines=32) @@
268		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
269		}
270
271		public function testUnAssignUserFromUserGroupStopPropagationInBeforeEvents()
272		{
273		$traceableEventDispatcher = $this->getEventDispatcher(
274		BeforeUnAssignUserFromUserGroupEvent::class,
275		UnAssignUserFromUserGroupEvent::class
276		);
277
278		$parameters = [
279		$this->createMock(User::class),
280		$this->createMock(UserGroup::class),
281		];
282
283		$innerServiceMock = $this->createMock(UserServiceInterface::class);
284
285		$traceableEventDispatcher->addListener(BeforeUnAssignUserFromUserGroupEvent::class, function (BeforeUnAssignUserFromUserGroupEvent $event) {
286		$event->stopPropagation();
287		}, 10);
288
289		$service = new UserService($innerServiceMock, $traceableEventDispatcher);
290		$service->unAssignUserFromUserGroup(...$parameters);
291
292		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
293		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
294
295		$this->assertSame($calledListeners, [
296		[BeforeUnAssignUserFromUserGroupEvent::class, 10],
297		]);
298		$this->assertSame($notCalledListeners, [
299		[BeforeUnAssignUserFromUserGroupEvent::class, 0],
300		[UnAssignUserFromUserGroupEvent::class, 0],
301		]);
302		}
303
304		public function testDeleteUserGroupEvents()
305		{
		@@ 429-460 (lines=32) @@
426		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
427		}
428
429		public function testAssignUserToUserGroupStopPropagationInBeforeEvents()
430		{
431		$traceableEventDispatcher = $this->getEventDispatcher(
432		BeforeAssignUserToUserGroupEvent::class,
433		AssignUserToUserGroupEvent::class
434		);
435
436		$parameters = [
437		$this->createMock(User::class),
438		$this->createMock(UserGroup::class),
439		];
440
441		$innerServiceMock = $this->createMock(UserServiceInterface::class);
442
443		$traceableEventDispatcher->addListener(BeforeAssignUserToUserGroupEvent::class, function (BeforeAssignUserToUserGroupEvent $event) {
444		$event->stopPropagation();
445		}, 10);
446
447		$service = new UserService($innerServiceMock, $traceableEventDispatcher);
448		$service->assignUserToUserGroup(...$parameters);
449
450		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
451		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
452
453		$this->assertSame($calledListeners, [
454		[BeforeAssignUserToUserGroupEvent::class, 10],
455		]);
456		$this->assertSame($notCalledListeners, [
457		[AssignUserToUserGroupEvent::class, 0],
458		[BeforeAssignUserToUserGroupEvent::class, 0],
459		]);
460		}
461
462		public function testDeleteUserEvents()
463		{
		@@ 587-618 (lines=32) @@
584		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
585		}
586
587		public function testMoveUserGroupStopPropagationInBeforeEvents()
588		{
589		$traceableEventDispatcher = $this->getEventDispatcher(
590		BeforeMoveUserGroupEvent::class,
591		MoveUserGroupEvent::class
592		);
593
594		$parameters = [
595		$this->createMock(UserGroup::class),
596		$this->createMock(UserGroup::class),
597		];
598
599		$innerServiceMock = $this->createMock(UserServiceInterface::class);
600
601		$traceableEventDispatcher->addListener(BeforeMoveUserGroupEvent::class, function (BeforeMoveUserGroupEvent $event) {
602		$event->stopPropagation();
603		}, 10);
604
605		$service = new UserService($innerServiceMock, $traceableEventDispatcher);
606		$service->moveUserGroup(...$parameters);
607
608		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
609		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
610
611		$this->assertSame($calledListeners, [
612		[BeforeMoveUserGroupEvent::class, 10],
613		]);
614		$this->assertSame($notCalledListeners, [
615		[BeforeMoveUserGroupEvent::class, 0],
616		[MoveUserGroupEvent::class, 0],
617		]);
618		}
619
620		public function testCreateUserEvents()
621		{

ezsystems / ezpublish-kernel

Code Duplication Length = 32-33 lines in 18 locations

eZ/Publish/Core/Event/Tests/ContentServiceTest.php 1 location

eZ/Publish/Core/Event/Tests/ContentTypeServiceTest.php 7 locations

eZ/Publish/Core/Event/Tests/LocationServiceTest.php 2 locations

eZ/Publish/Core/Event/Tests/ObjectStateServiceTest.php 1 location

eZ/Publish/Core/Event/Tests/RoleServiceTest.php 2 locations

eZ/Publish/Core/Event/Tests/SectionServiceTest.php 2 locations

eZ/Publish/Core/Event/Tests/UserServiceTest.php 3 locations