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

Code Duplication Length = 37-38 lines in 26 locations

eZ/Publish/Core/Event/Tests/ContentServiceTest.php 5 locations


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

    public function testCopyContentStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ContentEvents::BEFORE_COPY_CONTENT,
            ContentEvents::COPY_CONTENT
        );

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

        $content = $this->createMock(Content::class);
        $eventContent = $this->createMock(Content::class);
        $innerServiceMock = $this->createMock(ContentServiceInterface::class);
        $innerServiceMock->method('copyContent')->willReturn($content);

        $traceableEventDispatcher->addListener(ContentEvents::BEFORE_COPY_CONTENT, function (BeforeCopyContentEvent $event) use ($eventContent) {
            $event->setContent($eventContent);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventContent, $result);
        $this->assertSame($calledListeners, [
            [ContentEvents::BEFORE_COPY_CONTENT, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ContentEvents::COPY_CONTENT, 0],
            [ContentEvents::BEFORE_COPY_CONTENT, 0],
        ]);
    }

    public function testUpdateContentEvents()
    {

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

    public function testUpdateContentStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ContentEvents::BEFORE_UPDATE_CONTENT,
            ContentEvents::UPDATE_CONTENT
        );

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

        $content = $this->createMock(Content::class);
        $eventContent = $this->createMock(Content::class);
        $innerServiceMock = $this->createMock(ContentServiceInterface::class);
        $innerServiceMock->method('updateContent')->willReturn($content);

        $traceableEventDispatcher->addListener(ContentEvents::BEFORE_UPDATE_CONTENT, function (BeforeUpdateContentEvent $event) use ($eventContent) {
            $event->setContent($eventContent);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventContent, $result);
        $this->assertSame($calledListeners, [
            [ContentEvents::BEFORE_UPDATE_CONTENT, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ContentEvents::UPDATE_CONTENT, 0],
            [ContentEvents::BEFORE_UPDATE_CONTENT, 0],
        ]);
    }

    public function testDeleteRelationEvents()
    {

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

    public function testAddRelationStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ContentEvents::BEFORE_ADD_RELATION,
            ContentEvents::ADD_RELATION
        );

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

        $relation = $this->createMock(Relation::class);
        $eventRelation = $this->createMock(Relation::class);
        $innerServiceMock = $this->createMock(ContentServiceInterface::class);
        $innerServiceMock->method('addRelation')->willReturn($relation);

        $traceableEventDispatcher->addListener(ContentEvents::BEFORE_ADD_RELATION, function (BeforeAddRelationEvent $event) use ($eventRelation) {
            $event->setRelation($eventRelation);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventRelation, $result);
        $this->assertSame($calledListeners, [
            [ContentEvents::BEFORE_ADD_RELATION, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ContentEvents::ADD_RELATION, 0],
            [ContentEvents::BEFORE_ADD_RELATION, 0],
        ]);
    }

    public function testUpdateContentMetadataEvents()
    {

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

    public function testUpdateContentMetadataStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ContentEvents::BEFORE_UPDATE_CONTENT_METADATA,
            ContentEvents::UPDATE_CONTENT_METADATA
        );

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

        $content = $this->createMock(Content::class);
        $eventContent = $this->createMock(Content::class);
        $innerServiceMock = $this->createMock(ContentServiceInterface::class);
        $innerServiceMock->method('updateContentMetadata')->willReturn($content);

        $traceableEventDispatcher->addListener(ContentEvents::BEFORE_UPDATE_CONTENT_METADATA, function (BeforeUpdateContentMetadataEvent $event) use ($eventContent) {
            $event->setContent($eventContent);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventContent, $result);
        $this->assertSame($calledListeners, [
            [ContentEvents::BEFORE_UPDATE_CONTENT_METADATA, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ContentEvents::UPDATE_CONTENT_METADATA, 0],
            [ContentEvents::BEFORE_UPDATE_CONTENT_METADATA, 0],
        ]);
    }

    public function testDeleteTranslationEvents()
    {

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

    public function testCreateContentDraftStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ContentEvents::BEFORE_CREATE_CONTENT_DRAFT,
            ContentEvents::CREATE_CONTENT_DRAFT
        );

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

        $contentDraft = $this->createMock(Content::class);
        $eventContentDraft = $this->createMock(Content::class);
        $innerServiceMock = $this->createMock(ContentServiceInterface::class);
        $innerServiceMock->method('createContentDraft')->willReturn($contentDraft);

        $traceableEventDispatcher->addListener(ContentEvents::BEFORE_CREATE_CONTENT_DRAFT, function (BeforeCreateContentDraftEvent $event) use ($eventContentDraft) {
            $event->setContentDraft($eventContentDraft);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventContentDraft, $result);
        $this->assertSame($calledListeners, [
            [ContentEvents::BEFORE_CREATE_CONTENT_DRAFT, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ContentEvents::CREATE_CONTENT_DRAFT, 0],
            [ContentEvents::BEFORE_CREATE_CONTENT_DRAFT, 0],
        ]);
    }

    public function testRevealContentEvents()
    {

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


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

    public function testCopyContentTypeStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE,
            ContentTypeEvents::COPY_CONTENT_TYPE
        );

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

        $contentTypeCopy = $this->createMock(ContentType::class);
        $eventContentTypeCopy = $this->createMock(ContentType::class);
        $innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
        $innerServiceMock->method('copyContentType')->willReturn($contentTypeCopy);

        $traceableEventDispatcher->addListener(ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE, function (BeforeCopyContentTypeEvent $event) use ($eventContentTypeCopy) {
            $event->setContentTypeCopy($eventContentTypeCopy);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventContentTypeCopy, $result);
        $this->assertSame($calledListeners, [
            [ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ContentTypeEvents::COPY_CONTENT_TYPE, 0],
            [ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE, 0],
        ]);
    }
}


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


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

    public function testCopySubtreeStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            LocationEvents::BEFORE_COPY_SUBTREE,
            LocationEvents::COPY_SUBTREE
        );

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

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

        $traceableEventDispatcher->addListener(LocationEvents::BEFORE_COPY_SUBTREE, function (BeforeCopySubtreeEvent $event) use ($eventLocation) {
            $event->setLocation($eventLocation);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventLocation, $result);
        $this->assertSame($calledListeners, [
            [LocationEvents::BEFORE_COPY_SUBTREE, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [LocationEvents::COPY_SUBTREE, 0],
            [LocationEvents::BEFORE_COPY_SUBTREE, 0],
        ]);
    }

    public function testDeleteLocationEvents()
    {

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

    public function testUpdateLocationStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            LocationEvents::BEFORE_UPDATE_LOCATION,
            LocationEvents::UPDATE_LOCATION
        );

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

        $updatedLocation = $this->createMock(Location::class);
        $eventUpdatedLocation = $this->createMock(Location::class);
        $innerServiceMock = $this->createMock(LocationServiceInterface::class);
        $innerServiceMock->method('updateLocation')->willReturn($updatedLocation);

        $traceableEventDispatcher->addListener(LocationEvents::BEFORE_UPDATE_LOCATION, function (BeforeUpdateLocationEvent $event) use ($eventUpdatedLocation) {
            $event->setUpdatedLocation($eventUpdatedLocation);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedLocation, $result);
        $this->assertSame($calledListeners, [
            [LocationEvents::BEFORE_UPDATE_LOCATION, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [LocationEvents::UPDATE_LOCATION, 0],
            [LocationEvents::BEFORE_UPDATE_LOCATION, 0],
        ]);
    }

    public function testCreateLocationEvents()
    {

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

    public function testCreateLocationStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            LocationEvents::BEFORE_CREATE_LOCATION,
            LocationEvents::CREATE_LOCATION
        );

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

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

        $traceableEventDispatcher->addListener(LocationEvents::BEFORE_CREATE_LOCATION, function (BeforeCreateLocationEvent $event) use ($eventLocation) {
            $event->setLocation($eventLocation);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventLocation, $result);
        $this->assertSame($calledListeners, [
            [LocationEvents::BEFORE_CREATE_LOCATION, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [LocationEvents::CREATE_LOCATION, 0],
            [LocationEvents::BEFORE_CREATE_LOCATION, 0],
        ]);
    }
}


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


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

    public function testUpdateObjectStateStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE,
            ObjectStateEvents::UPDATE_OBJECT_STATE
        );

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

        $updatedObjectState = $this->createMock(ObjectState::class);
        $eventUpdatedObjectState = $this->createMock(ObjectState::class);
        $innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);
        $innerServiceMock->method('updateObjectState')->willReturn($updatedObjectState);

        $traceableEventDispatcher->addListener(ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE, function (BeforeUpdateObjectStateEvent $event) use ($eventUpdatedObjectState) {
            $event->setUpdatedObjectState($eventUpdatedObjectState);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedObjectState, $result);
        $this->assertSame($calledListeners, [
            [ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ObjectStateEvents::UPDATE_OBJECT_STATE, 0],
            [ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE, 0],
        ]);
    }

    public function testCreateObjectStateEvents()
    {

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

    public function testCreateObjectStateStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE,
            ObjectStateEvents::CREATE_OBJECT_STATE
        );

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

        $objectState = $this->createMock(ObjectState::class);
        $eventObjectState = $this->createMock(ObjectState::class);
        $innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);
        $innerServiceMock->method('createObjectState')->willReturn($objectState);

        $traceableEventDispatcher->addListener(ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE, function (BeforeCreateObjectStateEvent $event) use ($eventObjectState) {
            $event->setObjectState($eventObjectState);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventObjectState, $result);
        $this->assertSame($calledListeners, [
            [ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ObjectStateEvents::CREATE_OBJECT_STATE, 0],
            [ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE, 0],
        ]);
    }

    public function testUpdateObjectStateGroupEvents()
    {

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

    public function testUpdateObjectStateGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP,
            ObjectStateEvents::UPDATE_OBJECT_STATE_GROUP
        );

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

        $updatedObjectStateGroup = $this->createMock(ObjectStateGroup::class);
        $eventUpdatedObjectStateGroup = $this->createMock(ObjectStateGroup::class);
        $innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);
        $innerServiceMock->method('updateObjectStateGroup')->willReturn($updatedObjectStateGroup);

        $traceableEventDispatcher->addListener(ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP, function (BeforeUpdateObjectStateGroupEvent $event) use ($eventUpdatedObjectStateGroup) {
            $event->setUpdatedObjectStateGroup($eventUpdatedObjectStateGroup);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedObjectStateGroup, $result);
        $this->assertSame($calledListeners, [
            [ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [ObjectStateEvents::UPDATE_OBJECT_STATE_GROUP, 0],
            [ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP, 0],
        ]);
    }

    public function testSetPriorityOfObjectStateEvents()
    {

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


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

    public function testUpdateRoleStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            RoleEvents::BEFORE_UPDATE_ROLE,
            RoleEvents::UPDATE_ROLE
        );

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

        $updatedRole = $this->createMock(Role::class);
        $eventUpdatedRole = $this->createMock(Role::class);
        $innerServiceMock = $this->createMock(RoleServiceInterface::class);
        $innerServiceMock->method('updateRole')->willReturn($updatedRole);

        $traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_ROLE, function (BeforeUpdateRoleEvent $event) use ($eventUpdatedRole) {
            $event->setUpdatedRole($eventUpdatedRole);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedRole, $result);
        $this->assertSame($calledListeners, [
            [RoleEvents::BEFORE_UPDATE_ROLE, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [RoleEvents::UPDATE_ROLE, 0],
            [RoleEvents::BEFORE_UPDATE_ROLE, 0],
        ]);
    }

    public function testPublishRoleDraftEvents()
    {

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

    public function testAddPolicyStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            RoleEvents::BEFORE_ADD_POLICY,
            RoleEvents::ADD_POLICY
        );

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

        $updatedRole = $this->createMock(Role::class);
        $eventUpdatedRole = $this->createMock(Role::class);
        $innerServiceMock = $this->createMock(RoleServiceInterface::class);
        $innerServiceMock->method('addPolicy')->willReturn($updatedRole);

        $traceableEventDispatcher->addListener(RoleEvents::BEFORE_ADD_POLICY, function (BeforeAddPolicyEvent $event) use ($eventUpdatedRole) {
            $event->setUpdatedRole($eventUpdatedRole);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedRole, $result);
        $this->assertSame($calledListeners, [
            [RoleEvents::BEFORE_ADD_POLICY, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [RoleEvents::ADD_POLICY, 0],
            [RoleEvents::BEFORE_ADD_POLICY, 0],
        ]);
    }

    public function testUpdateRoleDraftEvents()
    {

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

    public function testUpdateRoleDraftStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            RoleEvents::BEFORE_UPDATE_ROLE_DRAFT,
            RoleEvents::UPDATE_ROLE_DRAFT
        );

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

        $updatedRoleDraft = $this->createMock(RoleDraft::class);
        $eventUpdatedRoleDraft = $this->createMock(RoleDraft::class);
        $innerServiceMock = $this->createMock(RoleServiceInterface::class);
        $innerServiceMock->method('updateRoleDraft')->willReturn($updatedRoleDraft);

        $traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, function (BeforeUpdateRoleDraftEvent $event) use ($eventUpdatedRoleDraft) {
            $event->setUpdatedRoleDraft($eventUpdatedRoleDraft);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedRoleDraft, $result);
        $this->assertSame($calledListeners, [
            [RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [RoleEvents::UPDATE_ROLE_DRAFT, 0],
            [RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, 0],
        ]);
    }

    public function testAssignRoleToUserGroupEvents()
    {

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

    public function testUpdatePolicyByRoleDraftStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT,
            RoleEvents::UPDATE_POLICY_BY_ROLE_DRAFT
        );

        $parameters = [
            $this->createMock(RoleDraft::class),
            $this->createMock(PolicyDraft::class),
            $this->createMock(PolicyUpdateStruct::class),
        ];

        $updatedPolicyDraft = $this->createMock(PolicyDraft::class);
        $eventUpdatedPolicyDraft = $this->createMock(PolicyDraft::class);
        $innerServiceMock = $this->createMock(RoleServiceInterface::class);
        $innerServiceMock->method('updatePolicyByRoleDraft')->willReturn($updatedPolicyDraft);

        $traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, function (BeforeUpdatePolicyByRoleDraftEvent $event) use ($eventUpdatedPolicyDraft) {
            $event->setUpdatedPolicyDraft($eventUpdatedPolicyDraft);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedPolicyDraft, $result);
        $this->assertSame($calledListeners, [
            [RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [RoleEvents::UPDATE_POLICY_BY_ROLE_DRAFT, 0],
            [RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, 0],
        ]);
    }

    public function testCreateRoleEvents()
    {

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

    public function testRemovePolicyByRoleDraftStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT,
            RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT
        );

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

        $updatedRoleDraft = $this->createMock(RoleDraft::class);
        $eventUpdatedRoleDraft = $this->createMock(RoleDraft::class);
        $innerServiceMock = $this->createMock(RoleServiceInterface::class);
        $innerServiceMock->method('removePolicyByRoleDraft')->willReturn($updatedRoleDraft);

        $traceableEventDispatcher->addListener(RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, function (BeforeRemovePolicyByRoleDraftEvent $event) use ($eventUpdatedRoleDraft) {
            $event->setUpdatedRoleDraft($eventUpdatedRoleDraft);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedRoleDraft, $result);
        $this->assertSame($calledListeners, [
            [RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT, 0],
            [RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, 0],
        ]);
    }

    public function testAddPolicyByRoleDraftEvents()
    {

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

    public function testAddPolicyByRoleDraftStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT,
            RoleEvents::ADD_POLICY_BY_ROLE_DRAFT
        );

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

        $updatedRoleDraft = $this->createMock(RoleDraft::class);
        $eventUpdatedRoleDraft = $this->createMock(RoleDraft::class);
        $innerServiceMock = $this->createMock(RoleServiceInterface::class);
        $innerServiceMock->method('addPolicyByRoleDraft')->willReturn($updatedRoleDraft);

        $traceableEventDispatcher->addListener(RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, function (BeforeAddPolicyByRoleDraftEvent $event) use ($eventUpdatedRoleDraft) {
            $event->setUpdatedRoleDraft($eventUpdatedRoleDraft);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedRoleDraft, $result);
        $this->assertSame($calledListeners, [
            [RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [RoleEvents::ADD_POLICY_BY_ROLE_DRAFT, 0],
            [RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, 0],
        ]);
    }

    public function testDeleteRoleEvents()
    {

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

    public function testUpdatePolicyStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            RoleEvents::BEFORE_UPDATE_POLICY,
            RoleEvents::UPDATE_POLICY
        );

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

        $updatedPolicy = $this->createMock(Policy::class);
        $eventUpdatedPolicy = $this->createMock(Policy::class);
        $innerServiceMock = $this->createMock(RoleServiceInterface::class);
        $innerServiceMock->method('updatePolicy')->willReturn($updatedPolicy);

        $traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_POLICY, function (BeforeUpdatePolicyEvent $event) use ($eventUpdatedPolicy) {
            $event->setUpdatedPolicy($eventUpdatedPolicy);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedPolicy, $result);
        $this->assertSame($calledListeners, [
            [RoleEvents::BEFORE_UPDATE_POLICY, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [RoleEvents::UPDATE_POLICY, 0],
            [RoleEvents::BEFORE_UPDATE_POLICY, 0],
        ]);
    }

    public function testUnassignRoleFromUserGroupEvents()
    {

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


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

    public function testUpdateSectionStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            SectionEvents::BEFORE_UPDATE_SECTION,
            SectionEvents::UPDATE_SECTION
        );

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

        $updatedSection = $this->createMock(Section::class);
        $eventUpdatedSection = $this->createMock(Section::class);
        $innerServiceMock = $this->createMock(SectionServiceInterface::class);
        $innerServiceMock->method('updateSection')->willReturn($updatedSection);

        $traceableEventDispatcher->addListener(SectionEvents::BEFORE_UPDATE_SECTION, function (BeforeUpdateSectionEvent $event) use ($eventUpdatedSection) {
            $event->setUpdatedSection($eventUpdatedSection);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedSection, $result);
        $this->assertSame($calledListeners, [
            [SectionEvents::BEFORE_UPDATE_SECTION, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [SectionEvents::UPDATE_SECTION, 0],
            [SectionEvents::BEFORE_UPDATE_SECTION, 0],
        ]);
    }

    public function testAssignSectionToSubtreeEvents()
    {

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


        $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()
    {

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


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

    public function testUpdateUrlStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            URLEvents::BEFORE_UPDATE_URL,
            URLEvents::UPDATE_URL
        );

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

        $updatedUrl = $this->createMock(URL::class);
        $eventUpdatedUrl = $this->createMock(URL::class);
        $innerServiceMock = $this->createMock(URLServiceInterface::class);
        $innerServiceMock->method('updateUrl')->willReturn($updatedUrl);

        $traceableEventDispatcher->addListener(URLEvents::BEFORE_UPDATE_URL, function (BeforeUpdateUrlEvent $event) use ($eventUpdatedUrl) {
            $event->setUpdatedUrl($eventUpdatedUrl);
            $event->stopPropagation();
        }, 10);

        $service = new URLService($innerServiceMock, $traceableEventDispatcher);
        $result = $service->updateUrl(...$parameters);

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

        $this->assertSame($eventUpdatedUrl, $result);
        $this->assertSame($calledListeners, [
            [URLEvents::BEFORE_UPDATE_URL, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [URLEvents::UPDATE_URL, 0],
            [URLEvents::BEFORE_UPDATE_URL, 0],
        ]);
    }
}


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


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

    public function testUpdateUserGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            UserEvents::BEFORE_UPDATE_USER_GROUP,
            UserEvents::UPDATE_USER_GROUP
        );

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

        $updatedUserGroup = $this->createMock(UserGroup::class);
        $eventUpdatedUserGroup = $this->createMock(UserGroup::class);
        $innerServiceMock = $this->createMock(UserServiceInterface::class);
        $innerServiceMock->method('updateUserGroup')->willReturn($updatedUserGroup);

        $traceableEventDispatcher->addListener(UserEvents::BEFORE_UPDATE_USER_GROUP, function (BeforeUpdateUserGroupEvent $event) use ($eventUpdatedUserGroup) {
            $event->setUpdatedUserGroup($eventUpdatedUserGroup);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedUserGroup, $result);
        $this->assertSame($calledListeners, [
            [UserEvents::BEFORE_UPDATE_USER_GROUP, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [UserEvents::UPDATE_USER_GROUP, 0],
            [UserEvents::BEFORE_UPDATE_USER_GROUP, 0],
        ]);
    }

    public function testUpdateUserEvents()
    {

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

    public function testUpdateUserStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            UserEvents::BEFORE_UPDATE_USER,
            UserEvents::UPDATE_USER
        );

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

        $updatedUser = $this->createMock(User::class);
        $eventUpdatedUser = $this->createMock(User::class);
        $innerServiceMock = $this->createMock(UserServiceInterface::class);
        $innerServiceMock->method('updateUser')->willReturn($updatedUser);

        $traceableEventDispatcher->addListener(UserEvents::BEFORE_UPDATE_USER, function (BeforeUpdateUserEvent $event) use ($eventUpdatedUser) {
            $event->setUpdatedUser($eventUpdatedUser);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedUser, $result);
        $this->assertSame($calledListeners, [
            [UserEvents::BEFORE_UPDATE_USER, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [UserEvents::UPDATE_USER, 0],
            [UserEvents::BEFORE_UPDATE_USER, 0],
        ]);
    }

    public function testUnAssignUserFromUserGroupEvents()
    {

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

    public function testCreateUserGroupStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            UserEvents::BEFORE_CREATE_USER_GROUP,
            UserEvents::CREATE_USER_GROUP
        );

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

        $userGroup = $this->createMock(UserGroup::class);
        $eventUserGroup = $this->createMock(UserGroup::class);
        $innerServiceMock = $this->createMock(UserServiceInterface::class);
        $innerServiceMock->method('createUserGroup')->willReturn($userGroup);

        $traceableEventDispatcher->addListener(UserEvents::BEFORE_CREATE_USER_GROUP, function (BeforeCreateUserGroupEvent $event) use ($eventUserGroup) {
            $event->setUserGroup($eventUserGroup);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUserGroup, $result);
        $this->assertSame($calledListeners, [
            [UserEvents::BEFORE_CREATE_USER_GROUP, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [UserEvents::CREATE_USER_GROUP, 0],
            [UserEvents::BEFORE_CREATE_USER_GROUP, 0],
        ]);
    }

    public function testUpdateUserTokenEvents()
    {

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

    public function testUpdateUserTokenStopPropagationInBeforeEvents()
    {
        $traceableEventDispatcher = $this->getEventDispatcher(
            UserEvents::BEFORE_UPDATE_USER_TOKEN,
            UserEvents::UPDATE_USER_TOKEN
        );

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

        $updatedUser = $this->createMock(User::class);
        $eventUpdatedUser = $this->createMock(User::class);
        $innerServiceMock = $this->createMock(UserServiceInterface::class);
        $innerServiceMock->method('updateUserToken')->willReturn($updatedUser);

        $traceableEventDispatcher->addListener(UserEvents::BEFORE_UPDATE_USER_TOKEN, function (BeforeUpdateUserTokenEvent $event) use ($eventUpdatedUser) {
            $event->setUpdatedUser($eventUpdatedUser);
            $event->stopPropagation();
        }, 10);

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

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

        $this->assertSame($eventUpdatedUser, $result);
        $this->assertSame($calledListeners, [
            [UserEvents::BEFORE_UPDATE_USER_TOKEN, 10],
        ]);
        $this->assertSame($notCalledListeners, [
            [UserEvents::UPDATE_USER_TOKEN, 0],
            [UserEvents::BEFORE_UPDATE_USER_TOKEN, 0],
        ]);
    }
}


		@@ 1093-1129 (lines=37) @@
1090		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
1091		}
1092
1093		public function testCopyContentTypeStopPropagationInBeforeEvents()
1094		{
1095		$traceableEventDispatcher = $this->getEventDispatcher(
1096		ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE,
1097		ContentTypeEvents::COPY_CONTENT_TYPE
1098		);
1099
1100		$parameters = [
1101		$this->createMock(ContentType::class),
1102		$this->createMock(User::class),
1103		];
1104
1105		$contentTypeCopy = $this->createMock(ContentType::class);
1106		$eventContentTypeCopy = $this->createMock(ContentType::class);
1107		$innerServiceMock = $this->createMock(ContentTypeServiceInterface::class);
1108		$innerServiceMock->method('copyContentType')->willReturn($contentTypeCopy);
1109
1110		$traceableEventDispatcher->addListener(ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE, function (BeforeCopyContentTypeEvent $event) use ($eventContentTypeCopy) {
1111		$event->setContentTypeCopy($eventContentTypeCopy);
1112		$event->stopPropagation();
1113		}, 10);
1114
1115		$service = new ContentTypeService($innerServiceMock, $traceableEventDispatcher);
1116		$result = $service->copyContentType(...$parameters);
1117
1118		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
1119		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
1120
1121		$this->assertSame($eventContentTypeCopy, $result);
1122		$this->assertSame($calledListeners, [
1123		[ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE, 10],
1124		]);
1125		$this->assertSame($notCalledListeners, [
1126		[ContentTypeEvents::COPY_CONTENT_TYPE, 0],
1127		[ContentTypeEvents::BEFORE_COPY_CONTENT_TYPE, 0],
1128		]);
1129		}
1130		}
1131

		@@ 91-127 (lines=37) @@
88		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
89		}
90
91		public function testCopySubtreeStopPropagationInBeforeEvents()
92		{
93		$traceableEventDispatcher = $this->getEventDispatcher(
94		LocationEvents::BEFORE_COPY_SUBTREE,
95		LocationEvents::COPY_SUBTREE
96		);
97
98		$parameters = [
99		$this->createMock(Location::class),
100		$this->createMock(Location::class),
101		];
102
103		$location = $this->createMock(Location::class);
104		$eventLocation = $this->createMock(Location::class);
105		$innerServiceMock = $this->createMock(LocationServiceInterface::class);
106		$innerServiceMock->method('copySubtree')->willReturn($location);
107
108		$traceableEventDispatcher->addListener(LocationEvents::BEFORE_COPY_SUBTREE, function (BeforeCopySubtreeEvent $event) use ($eventLocation) {
109		$event->setLocation($eventLocation);
110		$event->stopPropagation();
111		}, 10);
112
113		$service = new LocationService($innerServiceMock, $traceableEventDispatcher);
114		$result = $service->copySubtree(...$parameters);
115
116		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
117		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
118
119		$this->assertSame($eventLocation, $result);
120		$this->assertSame($calledListeners, [
121		[LocationEvents::BEFORE_COPY_SUBTREE, 10],
122		]);
123		$this->assertSame($notCalledListeners, [
124		[LocationEvents::COPY_SUBTREE, 0],
125		[LocationEvents::BEFORE_COPY_SUBTREE, 0],
126		]);
127		}
128
129		public function testDeleteLocationEvents()
130		{
		@@ 566-602 (lines=37) @@
563		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
564		}
565
566		public function testUpdateLocationStopPropagationInBeforeEvents()
567		{
568		$traceableEventDispatcher = $this->getEventDispatcher(
569		LocationEvents::BEFORE_UPDATE_LOCATION,
570		LocationEvents::UPDATE_LOCATION
571		);
572
573		$parameters = [
574		$this->createMock(Location::class),
575		$this->createMock(LocationUpdateStruct::class),
576		];
577
578		$updatedLocation = $this->createMock(Location::class);
579		$eventUpdatedLocation = $this->createMock(Location::class);
580		$innerServiceMock = $this->createMock(LocationServiceInterface::class);
581		$innerServiceMock->method('updateLocation')->willReturn($updatedLocation);
582
583		$traceableEventDispatcher->addListener(LocationEvents::BEFORE_UPDATE_LOCATION, function (BeforeUpdateLocationEvent $event) use ($eventUpdatedLocation) {
584		$event->setUpdatedLocation($eventUpdatedLocation);
585		$event->stopPropagation();
586		}, 10);
587
588		$service = new LocationService($innerServiceMock, $traceableEventDispatcher);
589		$result = $service->updateLocation(...$parameters);
590
591		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
592		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
593
594		$this->assertSame($eventUpdatedLocation, $result);
595		$this->assertSame($calledListeners, [
596		[LocationEvents::BEFORE_UPDATE_LOCATION, 10],
597		]);
598		$this->assertSame($notCalledListeners, [
599		[LocationEvents::UPDATE_LOCATION, 0],
600		[LocationEvents::BEFORE_UPDATE_LOCATION, 0],
601		]);
602		}
603
604		public function testCreateLocationEvents()
605		{
		@@ 668-704 (lines=37) @@
665		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
666		}
667
668		public function testCreateLocationStopPropagationInBeforeEvents()
669		{
670		$traceableEventDispatcher = $this->getEventDispatcher(
671		LocationEvents::BEFORE_CREATE_LOCATION,
672		LocationEvents::CREATE_LOCATION
673		);
674
675		$parameters = [
676		$this->createMock(ContentInfo::class),
677		$this->createMock(LocationCreateStruct::class),
678		];
679
680		$location = $this->createMock(Location::class);
681		$eventLocation = $this->createMock(Location::class);
682		$innerServiceMock = $this->createMock(LocationServiceInterface::class);
683		$innerServiceMock->method('createLocation')->willReturn($location);
684
685		$traceableEventDispatcher->addListener(LocationEvents::BEFORE_CREATE_LOCATION, function (BeforeCreateLocationEvent $event) use ($eventLocation) {
686		$event->setLocation($eventLocation);
687		$event->stopPropagation();
688		}, 10);
689
690		$service = new LocationService($innerServiceMock, $traceableEventDispatcher);
691		$result = $service->createLocation(...$parameters);
692
693		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
694		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
695
696		$this->assertSame($eventLocation, $result);
697		$this->assertSame($calledListeners, [
698		[LocationEvents::BEFORE_CREATE_LOCATION, 10],
699		]);
700		$this->assertSame($notCalledListeners, [
701		[LocationEvents::CREATE_LOCATION, 0],
702		[LocationEvents::BEFORE_CREATE_LOCATION, 0],
703		]);
704		}
705		}
706

		@@ 254-290 (lines=37) @@
251		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
252		}
253
254		public function testUpdateObjectStateStopPropagationInBeforeEvents()
255		{
256		$traceableEventDispatcher = $this->getEventDispatcher(
257		ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE,
258		ObjectStateEvents::UPDATE_OBJECT_STATE
259		);
260
261		$parameters = [
262		$this->createMock(ObjectState::class),
263		$this->createMock(ObjectStateUpdateStruct::class),
264		];
265
266		$updatedObjectState = $this->createMock(ObjectState::class);
267		$eventUpdatedObjectState = $this->createMock(ObjectState::class);
268		$innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);
269		$innerServiceMock->method('updateObjectState')->willReturn($updatedObjectState);
270
271		$traceableEventDispatcher->addListener(ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE, function (BeforeUpdateObjectStateEvent $event) use ($eventUpdatedObjectState) {
272		$event->setUpdatedObjectState($eventUpdatedObjectState);
273		$event->stopPropagation();
274		}, 10);
275
276		$service = new ObjectStateService($innerServiceMock, $traceableEventDispatcher);
277		$result = $service->updateObjectState(...$parameters);
278
279		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
280		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
281
282		$this->assertSame($eventUpdatedObjectState, $result);
283		$this->assertSame($calledListeners, [
284		[ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE, 10],
285		]);
286		$this->assertSame($notCalledListeners, [
287		[ObjectStateEvents::UPDATE_OBJECT_STATE, 0],
288		[ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE, 0],
289		]);
290		}
291
292		public function testCreateObjectStateEvents()
293		{
		@@ 356-392 (lines=37) @@
353		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
354		}
355
356		public function testCreateObjectStateStopPropagationInBeforeEvents()
357		{
358		$traceableEventDispatcher = $this->getEventDispatcher(
359		ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE,
360		ObjectStateEvents::CREATE_OBJECT_STATE
361		);
362
363		$parameters = [
364		$this->createMock(ObjectStateGroup::class),
365		$this->createMock(ObjectStateCreateStruct::class),
366		];
367
368		$objectState = $this->createMock(ObjectState::class);
369		$eventObjectState = $this->createMock(ObjectState::class);
370		$innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);
371		$innerServiceMock->method('createObjectState')->willReturn($objectState);
372
373		$traceableEventDispatcher->addListener(ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE, function (BeforeCreateObjectStateEvent $event) use ($eventObjectState) {
374		$event->setObjectState($eventObjectState);
375		$event->stopPropagation();
376		}, 10);
377
378		$service = new ObjectStateService($innerServiceMock, $traceableEventDispatcher);
379		$result = $service->createObjectState(...$parameters);
380
381		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
382		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
383
384		$this->assertSame($eventObjectState, $result);
385		$this->assertSame($calledListeners, [
386		[ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE, 10],
387		]);
388		$this->assertSame($notCalledListeners, [
389		[ObjectStateEvents::CREATE_OBJECT_STATE, 0],
390		[ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE, 0],
391		]);
392		}
393
394		public function testUpdateObjectStateGroupEvents()
395		{
		@@ 458-494 (lines=37) @@
455		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
456		}
457
458		public function testUpdateObjectStateGroupStopPropagationInBeforeEvents()
459		{
460		$traceableEventDispatcher = $this->getEventDispatcher(
461		ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP,
462		ObjectStateEvents::UPDATE_OBJECT_STATE_GROUP
463		);
464
465		$parameters = [
466		$this->createMock(ObjectStateGroup::class),
467		$this->createMock(ObjectStateGroupUpdateStruct::class),
468		];
469
470		$updatedObjectStateGroup = $this->createMock(ObjectStateGroup::class);
471		$eventUpdatedObjectStateGroup = $this->createMock(ObjectStateGroup::class);
472		$innerServiceMock = $this->createMock(ObjectStateServiceInterface::class);
473		$innerServiceMock->method('updateObjectStateGroup')->willReturn($updatedObjectStateGroup);
474
475		$traceableEventDispatcher->addListener(ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP, function (BeforeUpdateObjectStateGroupEvent $event) use ($eventUpdatedObjectStateGroup) {
476		$event->setUpdatedObjectStateGroup($eventUpdatedObjectStateGroup);
477		$event->stopPropagation();
478		}, 10);
479
480		$service = new ObjectStateService($innerServiceMock, $traceableEventDispatcher);
481		$result = $service->updateObjectStateGroup(...$parameters);
482
483		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
484		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
485
486		$this->assertSame($eventUpdatedObjectStateGroup, $result);
487		$this->assertSame($calledListeners, [
488		[ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP, 10],
489		]);
490		$this->assertSame($notCalledListeners, [
491		[ObjectStateEvents::UPDATE_OBJECT_STATE_GROUP, 0],
492		[ObjectStateEvents::BEFORE_UPDATE_OBJECT_STATE_GROUP, 0],
493		]);
494		}
495
496		public function testSetPriorityOfObjectStateEvents()
497		{

		@@ 148-184 (lines=37) @@
145		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
146		}
147
148		public function testUpdateSectionStopPropagationInBeforeEvents()
149		{
150		$traceableEventDispatcher = $this->getEventDispatcher(
151		SectionEvents::BEFORE_UPDATE_SECTION,
152		SectionEvents::UPDATE_SECTION
153		);
154
155		$parameters = [
156		$this->createMock(Section::class),
157		$this->createMock(SectionUpdateStruct::class),
158		];
159
160		$updatedSection = $this->createMock(Section::class);
161		$eventUpdatedSection = $this->createMock(Section::class);
162		$innerServiceMock = $this->createMock(SectionServiceInterface::class);
163		$innerServiceMock->method('updateSection')->willReturn($updatedSection);
164
165		$traceableEventDispatcher->addListener(SectionEvents::BEFORE_UPDATE_SECTION, function (BeforeUpdateSectionEvent $event) use ($eventUpdatedSection) {
166		$event->setUpdatedSection($eventUpdatedSection);
167		$event->stopPropagation();
168		}, 10);
169
170		$service = new SectionService($innerServiceMock, $traceableEventDispatcher);
171		$result = $service->updateSection(...$parameters);
172
173		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
174		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
175
176		$this->assertSame($eventUpdatedSection, $result);
177		$this->assertSame($calledListeners, [
178		[SectionEvents::BEFORE_UPDATE_SECTION, 10],
179		]);
180		$this->assertSame($notCalledListeners, [
181		[SectionEvents::UPDATE_SECTION, 0],
182		[SectionEvents::BEFORE_UPDATE_SECTION, 0],
183		]);
184		}
185
186		public function testAssignSectionToSubtreeEvents()
187		{

		@@ 282-318 (lines=37) @@
279		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
280		}
281
282		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		{

		@@ 202-239 (lines=38) @@
199		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
200		}
201
202		public function testCopyContentStopPropagationInBeforeEvents()
203		{
204		$traceableEventDispatcher = $this->getEventDispatcher(
205		ContentEvents::BEFORE_COPY_CONTENT,
206		ContentEvents::COPY_CONTENT
207		);
208
209		$parameters = [
210		$this->createMock(ContentInfo::class),
211		$this->createMock(LocationCreateStruct::class),
212		$this->createMock(VersionInfo::class),
213		];
214
215		$content = $this->createMock(Content::class);
216		$eventContent = $this->createMock(Content::class);
217		$innerServiceMock = $this->createMock(ContentServiceInterface::class);
218		$innerServiceMock->method('copyContent')->willReturn($content);
219
220		$traceableEventDispatcher->addListener(ContentEvents::BEFORE_COPY_CONTENT, function (BeforeCopyContentEvent $event) use ($eventContent) {
221		$event->setContent($eventContent);
222		$event->stopPropagation();
223		}, 10);
224
225		$service = new ContentService($innerServiceMock, $traceableEventDispatcher);
226		$result = $service->copyContent(...$parameters);
227
228		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
229		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
230
231		$this->assertSame($eventContent, $result);
232		$this->assertSame($calledListeners, [
233		[ContentEvents::BEFORE_COPY_CONTENT, 10],
234		]);
235		$this->assertSame($notCalledListeners, [
236		[ContentEvents::COPY_CONTENT, 0],
237		[ContentEvents::BEFORE_COPY_CONTENT, 0],
238		]);
239		}
240
241		public function testUpdateContentEvents()
242		{
		@@ 305-341 (lines=37) @@
302		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
303		}
304
305		public function testUpdateContentStopPropagationInBeforeEvents()
306		{
307		$traceableEventDispatcher = $this->getEventDispatcher(
308		ContentEvents::BEFORE_UPDATE_CONTENT,
309		ContentEvents::UPDATE_CONTENT
310		);
311
312		$parameters = [
313		$this->createMock(VersionInfo::class),
314		$this->createMock(ContentUpdateStruct::class),
315		];
316
317		$content = $this->createMock(Content::class);
318		$eventContent = $this->createMock(Content::class);
319		$innerServiceMock = $this->createMock(ContentServiceInterface::class);
320		$innerServiceMock->method('updateContent')->willReturn($content);
321
322		$traceableEventDispatcher->addListener(ContentEvents::BEFORE_UPDATE_CONTENT, function (BeforeUpdateContentEvent $event) use ($eventContent) {
323		$event->setContent($eventContent);
324		$event->stopPropagation();
325		}, 10);
326
327		$service = new ContentService($innerServiceMock, $traceableEventDispatcher);
328		$result = $service->updateContent(...$parameters);
329
330		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
331		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
332
333		$this->assertSame($eventContent, $result);
334		$this->assertSame($calledListeners, [
335		[ContentEvents::BEFORE_UPDATE_CONTENT, 10],
336		]);
337		$this->assertSame($notCalledListeners, [
338		[ContentEvents::UPDATE_CONTENT, 0],
339		[ContentEvents::BEFORE_UPDATE_CONTENT, 0],
340		]);
341		}
342
343		public function testDeleteRelationEvents()
344		{
		@@ 682-718 (lines=37) @@
679		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
680		}
681
682		public function testAddRelationStopPropagationInBeforeEvents()
683		{
684		$traceableEventDispatcher = $this->getEventDispatcher(
685		ContentEvents::BEFORE_ADD_RELATION,
686		ContentEvents::ADD_RELATION
687		);
688
689		$parameters = [
690		$this->createMock(VersionInfo::class),
691		$this->createMock(ContentInfo::class),
692		];
693
694		$relation = $this->createMock(Relation::class);
695		$eventRelation = $this->createMock(Relation::class);
696		$innerServiceMock = $this->createMock(ContentServiceInterface::class);
697		$innerServiceMock->method('addRelation')->willReturn($relation);
698
699		$traceableEventDispatcher->addListener(ContentEvents::BEFORE_ADD_RELATION, function (BeforeAddRelationEvent $event) use ($eventRelation) {
700		$event->setRelation($eventRelation);
701		$event->stopPropagation();
702		}, 10);
703
704		$service = new ContentService($innerServiceMock, $traceableEventDispatcher);
705		$result = $service->addRelation(...$parameters);
706
707		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
708		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
709
710		$this->assertSame($eventRelation, $result);
711		$this->assertSame($calledListeners, [
712		[ContentEvents::BEFORE_ADD_RELATION, 10],
713		]);
714		$this->assertSame($notCalledListeners, [
715		[ContentEvents::ADD_RELATION, 0],
716		[ContentEvents::BEFORE_ADD_RELATION, 0],
717		]);
718		}
719
720		public function testUpdateContentMetadataEvents()
721		{
		@@ 784-820 (lines=37) @@
781		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
782		}
783
784		public function testUpdateContentMetadataStopPropagationInBeforeEvents()
785		{
786		$traceableEventDispatcher = $this->getEventDispatcher(
787		ContentEvents::BEFORE_UPDATE_CONTENT_METADATA,
788		ContentEvents::UPDATE_CONTENT_METADATA
789		);
790
791		$parameters = [
792		$this->createMock(ContentInfo::class),
793		$this->createMock(ContentMetadataUpdateStruct::class),
794		];
795
796		$content = $this->createMock(Content::class);
797		$eventContent = $this->createMock(Content::class);
798		$innerServiceMock = $this->createMock(ContentServiceInterface::class);
799		$innerServiceMock->method('updateContentMetadata')->willReturn($content);
800
801		$traceableEventDispatcher->addListener(ContentEvents::BEFORE_UPDATE_CONTENT_METADATA, function (BeforeUpdateContentMetadataEvent $event) use ($eventContent) {
802		$event->setContent($eventContent);
803		$event->stopPropagation();
804		}, 10);
805
806		$service = new ContentService($innerServiceMock, $traceableEventDispatcher);
807		$result = $service->updateContentMetadata(...$parameters);
808
809		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
810		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
811
812		$this->assertSame($eventContent, $result);
813		$this->assertSame($calledListeners, [
814		[ContentEvents::BEFORE_UPDATE_CONTENT_METADATA, 10],
815		]);
816		$this->assertSame($notCalledListeners, [
817		[ContentEvents::UPDATE_CONTENT_METADATA, 0],
818		[ContentEvents::BEFORE_UPDATE_CONTENT_METADATA, 0],
819		]);
820		}
821
822		public function testDeleteTranslationEvents()
823		{
		@@ 1046-1083 (lines=38) @@
1043		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
1044		}
1045
1046		public function testCreateContentDraftStopPropagationInBeforeEvents()
1047		{
1048		$traceableEventDispatcher = $this->getEventDispatcher(
1049		ContentEvents::BEFORE_CREATE_CONTENT_DRAFT,
1050		ContentEvents::CREATE_CONTENT_DRAFT
1051		);
1052
1053		$parameters = [
1054		$this->createMock(ContentInfo::class),
1055		$this->createMock(VersionInfo::class),
1056		$this->createMock(User::class),
1057		];
1058
1059		$contentDraft = $this->createMock(Content::class);
1060		$eventContentDraft = $this->createMock(Content::class);
1061		$innerServiceMock = $this->createMock(ContentServiceInterface::class);
1062		$innerServiceMock->method('createContentDraft')->willReturn($contentDraft);
1063
1064		$traceableEventDispatcher->addListener(ContentEvents::BEFORE_CREATE_CONTENT_DRAFT, function (BeforeCreateContentDraftEvent $event) use ($eventContentDraft) {
1065		$event->setContentDraft($eventContentDraft);
1066		$event->stopPropagation();
1067		}, 10);
1068
1069		$service = new ContentService($innerServiceMock, $traceableEventDispatcher);
1070		$result = $service->createContentDraft(...$parameters);
1071
1072		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
1073		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
1074
1075		$this->assertSame($eventContentDraft, $result);
1076		$this->assertSame($calledListeners, [
1077		[ContentEvents::BEFORE_CREATE_CONTENT_DRAFT, 10],
1078		]);
1079		$this->assertSame($notCalledListeners, [
1080		[ContentEvents::CREATE_CONTENT_DRAFT, 0],
1081		[ContentEvents::BEFORE_CREATE_CONTENT_DRAFT, 0],
1082		]);
1083		}
1084
1085		public function testRevealContentEvents()
1086		{

		@@ 166-202 (lines=37) @@
163		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
164		}
165
166		public function testUpdateRoleStopPropagationInBeforeEvents()
167		{
168		$traceableEventDispatcher = $this->getEventDispatcher(
169		RoleEvents::BEFORE_UPDATE_ROLE,
170		RoleEvents::UPDATE_ROLE
171		);
172
173		$parameters = [
174		$this->createMock(Role::class),
175		$this->createMock(RoleUpdateStruct::class),
176		];
177
178		$updatedRole = $this->createMock(Role::class);
179		$eventUpdatedRole = $this->createMock(Role::class);
180		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
181		$innerServiceMock->method('updateRole')->willReturn($updatedRole);
182
183		$traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_ROLE, function (BeforeUpdateRoleEvent $event) use ($eventUpdatedRole) {
184		$event->setUpdatedRole($eventUpdatedRole);
185		$event->stopPropagation();
186		}, 10);
187
188		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
189		$result = $service->updateRole(...$parameters);
190
191		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
192		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
193
194		$this->assertSame($eventUpdatedRole, $result);
195		$this->assertSame($calledListeners, [
196		[RoleEvents::BEFORE_UPDATE_ROLE, 10],
197		]);
198		$this->assertSame($notCalledListeners, [
199		[RoleEvents::UPDATE_ROLE, 0],
200		[RoleEvents::BEFORE_UPDATE_ROLE, 0],
201		]);
202		}
203
204		public function testPublishRoleDraftEvents()
205		{
		@@ 386-422 (lines=37) @@
383		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
384		}
385
386		public function testAddPolicyStopPropagationInBeforeEvents()
387		{
388		$traceableEventDispatcher = $this->getEventDispatcher(
389		RoleEvents::BEFORE_ADD_POLICY,
390		RoleEvents::ADD_POLICY
391		);
392
393		$parameters = [
394		$this->createMock(Role::class),
395		$this->createMock(PolicyCreateStruct::class),
396		];
397
398		$updatedRole = $this->createMock(Role::class);
399		$eventUpdatedRole = $this->createMock(Role::class);
400		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
401		$innerServiceMock->method('addPolicy')->willReturn($updatedRole);
402
403		$traceableEventDispatcher->addListener(RoleEvents::BEFORE_ADD_POLICY, function (BeforeAddPolicyEvent $event) use ($eventUpdatedRole) {
404		$event->setUpdatedRole($eventUpdatedRole);
405		$event->stopPropagation();
406		}, 10);
407
408		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
409		$result = $service->addPolicy(...$parameters);
410
411		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
412		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
413
414		$this->assertSame($eventUpdatedRole, $result);
415		$this->assertSame($calledListeners, [
416		[RoleEvents::BEFORE_ADD_POLICY, 10],
417		]);
418		$this->assertSame($notCalledListeners, [
419		[RoleEvents::ADD_POLICY, 0],
420		[RoleEvents::BEFORE_ADD_POLICY, 0],
421		]);
422		}
423
424		public function testUpdateRoleDraftEvents()
425		{
		@@ 488-524 (lines=37) @@
485		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
486		}
487
488		public function testUpdateRoleDraftStopPropagationInBeforeEvents()
489		{
490		$traceableEventDispatcher = $this->getEventDispatcher(
491		RoleEvents::BEFORE_UPDATE_ROLE_DRAFT,
492		RoleEvents::UPDATE_ROLE_DRAFT
493		);
494
495		$parameters = [
496		$this->createMock(RoleDraft::class),
497		$this->createMock(RoleUpdateStruct::class),
498		];
499
500		$updatedRoleDraft = $this->createMock(RoleDraft::class);
501		$eventUpdatedRoleDraft = $this->createMock(RoleDraft::class);
502		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
503		$innerServiceMock->method('updateRoleDraft')->willReturn($updatedRoleDraft);
504
505		$traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, function (BeforeUpdateRoleDraftEvent $event) use ($eventUpdatedRoleDraft) {
506		$event->setUpdatedRoleDraft($eventUpdatedRoleDraft);
507		$event->stopPropagation();
508		}, 10);
509
510		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
511		$result = $service->updateRoleDraft(...$parameters);
512
513		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
514		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
515
516		$this->assertSame($eventUpdatedRoleDraft, $result);
517		$this->assertSame($calledListeners, [
518		[RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, 10],
519		]);
520		$this->assertSame($notCalledListeners, [
521		[RoleEvents::UPDATE_ROLE_DRAFT, 0],
522		[RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, 0],
523		]);
524		}
525
526		public function testAssignRoleToUserGroupEvents()
527		{
		@@ 712-749 (lines=38) @@
709		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
710		}
711
712		public function testUpdatePolicyByRoleDraftStopPropagationInBeforeEvents()
713		{
714		$traceableEventDispatcher = $this->getEventDispatcher(
715		RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT,
716		RoleEvents::UPDATE_POLICY_BY_ROLE_DRAFT
717		);
718
719		$parameters = [
720		$this->createMock(RoleDraft::class),
721		$this->createMock(PolicyDraft::class),
722		$this->createMock(PolicyUpdateStruct::class),
723		];
724
725		$updatedPolicyDraft = $this->createMock(PolicyDraft::class);
726		$eventUpdatedPolicyDraft = $this->createMock(PolicyDraft::class);
727		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
728		$innerServiceMock->method('updatePolicyByRoleDraft')->willReturn($updatedPolicyDraft);
729
730		$traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, function (BeforeUpdatePolicyByRoleDraftEvent $event) use ($eventUpdatedPolicyDraft) {
731		$event->setUpdatedPolicyDraft($eventUpdatedPolicyDraft);
732		$event->stopPropagation();
733		}, 10);
734
735		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
736		$result = $service->updatePolicyByRoleDraft(...$parameters);
737
738		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
739		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
740
741		$this->assertSame($eventUpdatedPolicyDraft, $result);
742		$this->assertSame($calledListeners, [
743		[RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, 10],
744		]);
745		$this->assertSame($notCalledListeners, [
746		[RoleEvents::UPDATE_POLICY_BY_ROLE_DRAFT, 0],
747		[RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, 0],
748		]);
749		}
750
751		public function testCreateRoleEvents()
752		{
		@@ 914-950 (lines=37) @@
911		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
912		}
913
914		public function testRemovePolicyByRoleDraftStopPropagationInBeforeEvents()
915		{
916		$traceableEventDispatcher = $this->getEventDispatcher(
917		RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT,
918		RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT
919		);
920
921		$parameters = [
922		$this->createMock(RoleDraft::class),
923		$this->createMock(PolicyDraft::class),
924		];
925
926		$updatedRoleDraft = $this->createMock(RoleDraft::class);
927		$eventUpdatedRoleDraft = $this->createMock(RoleDraft::class);
928		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
929		$innerServiceMock->method('removePolicyByRoleDraft')->willReturn($updatedRoleDraft);
930
931		$traceableEventDispatcher->addListener(RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, function (BeforeRemovePolicyByRoleDraftEvent $event) use ($eventUpdatedRoleDraft) {
932		$event->setUpdatedRoleDraft($eventUpdatedRoleDraft);
933		$event->stopPropagation();
934		}, 10);
935
936		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
937		$result = $service->removePolicyByRoleDraft(...$parameters);
938
939		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
940		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
941
942		$this->assertSame($eventUpdatedRoleDraft, $result);
943		$this->assertSame($calledListeners, [
944		[RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, 10],
945		]);
946		$this->assertSame($notCalledListeners, [
947		[RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT, 0],
948		[RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, 0],
949		]);
950		}
951
952		public function testAddPolicyByRoleDraftEvents()
953		{
		@@ 1016-1052 (lines=37) @@
1013		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
1014		}
1015
1016		public function testAddPolicyByRoleDraftStopPropagationInBeforeEvents()
1017		{
1018		$traceableEventDispatcher = $this->getEventDispatcher(
1019		RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT,
1020		RoleEvents::ADD_POLICY_BY_ROLE_DRAFT
1021		);
1022
1023		$parameters = [
1024		$this->createMock(RoleDraft::class),
1025		$this->createMock(PolicyCreateStruct::class),
1026		];
1027
1028		$updatedRoleDraft = $this->createMock(RoleDraft::class);
1029		$eventUpdatedRoleDraft = $this->createMock(RoleDraft::class);
1030		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
1031		$innerServiceMock->method('addPolicyByRoleDraft')->willReturn($updatedRoleDraft);
1032
1033		$traceableEventDispatcher->addListener(RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, function (BeforeAddPolicyByRoleDraftEvent $event) use ($eventUpdatedRoleDraft) {
1034		$event->setUpdatedRoleDraft($eventUpdatedRoleDraft);
1035		$event->stopPropagation();
1036		}, 10);
1037
1038		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
1039		$result = $service->addPolicyByRoleDraft(...$parameters);
1040
1041		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
1042		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
1043
1044		$this->assertSame($eventUpdatedRoleDraft, $result);
1045		$this->assertSame($calledListeners, [
1046		[RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, 10],
1047		]);
1048		$this->assertSame($notCalledListeners, [
1049		[RoleEvents::ADD_POLICY_BY_ROLE_DRAFT, 0],
1050		[RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, 0],
1051		]);
1052		}
1053
1054		public function testDeleteRoleEvents()
1055		{
		@@ 1388-1424 (lines=37) @@
1385		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
1386		}
1387
1388		public function testUpdatePolicyStopPropagationInBeforeEvents()
1389		{
1390		$traceableEventDispatcher = $this->getEventDispatcher(
1391		RoleEvents::BEFORE_UPDATE_POLICY,
1392		RoleEvents::UPDATE_POLICY
1393		);
1394
1395		$parameters = [
1396		$this->createMock(Policy::class),
1397		$this->createMock(PolicyUpdateStruct::class),
1398		];
1399
1400		$updatedPolicy = $this->createMock(Policy::class);
1401		$eventUpdatedPolicy = $this->createMock(Policy::class);
1402		$innerServiceMock = $this->createMock(RoleServiceInterface::class);
1403		$innerServiceMock->method('updatePolicy')->willReturn($updatedPolicy);
1404
1405		$traceableEventDispatcher->addListener(RoleEvents::BEFORE_UPDATE_POLICY, function (BeforeUpdatePolicyEvent $event) use ($eventUpdatedPolicy) {
1406		$event->setUpdatedPolicy($eventUpdatedPolicy);
1407		$event->stopPropagation();
1408		}, 10);
1409
1410		$service = new RoleService($innerServiceMock, $traceableEventDispatcher);
1411		$result = $service->updatePolicy(...$parameters);
1412
1413		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
1414		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
1415
1416		$this->assertSame($eventUpdatedPolicy, $result);
1417		$this->assertSame($calledListeners, [
1418		[RoleEvents::BEFORE_UPDATE_POLICY, 10],
1419		]);
1420		$this->assertSame($notCalledListeners, [
1421		[RoleEvents::UPDATE_POLICY, 0],
1422		[RoleEvents::BEFORE_UPDATE_POLICY, 0],
1423		]);
1424		}
1425
1426		public function testUnassignRoleFromUserGroupEvents()
1427		{

		@@ 82-118 (lines=37) @@
79		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
80		}
81
82		public function testUpdateUrlStopPropagationInBeforeEvents()
83		{
84		$traceableEventDispatcher = $this->getEventDispatcher(
85		URLEvents::BEFORE_UPDATE_URL,
86		URLEvents::UPDATE_URL
87		);
88
89		$parameters = [
90		$this->createMock(URL::class),
91		$this->createMock(URLUpdateStruct::class),
92		];
93
94		$updatedUrl = $this->createMock(URL::class);
95		$eventUpdatedUrl = $this->createMock(URL::class);
96		$innerServiceMock = $this->createMock(URLServiceInterface::class);
97		$innerServiceMock->method('updateUrl')->willReturn($updatedUrl);
98
99		$traceableEventDispatcher->addListener(URLEvents::BEFORE_UPDATE_URL, function (BeforeUpdateUrlEvent $event) use ($eventUpdatedUrl) {
100		$event->setUpdatedUrl($eventUpdatedUrl);
101		$event->stopPropagation();
102		}, 10);
103
104		$service = new URLService($innerServiceMock, $traceableEventDispatcher);
105		$result = $service->updateUrl(...$parameters);
106
107		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
108		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
109
110		$this->assertSame($eventUpdatedUrl, $result);
111		$this->assertSame($calledListeners, [
112		[URLEvents::BEFORE_UPDATE_URL, 10],
113		]);
114		$this->assertSame($notCalledListeners, [
115		[URLEvents::UPDATE_URL, 0],
116		[URLEvents::BEFORE_UPDATE_URL, 0],
117		]);
118		}
119		}
120

		@@ 96-132 (lines=37) @@
93		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
94		}
95
96		public function testUpdateUserGroupStopPropagationInBeforeEvents()
97		{
98		$traceableEventDispatcher = $this->getEventDispatcher(
99		UserEvents::BEFORE_UPDATE_USER_GROUP,
100		UserEvents::UPDATE_USER_GROUP
101		);
102
103		$parameters = [
104		$this->createMock(UserGroup::class),
105		$this->createMock(UserGroupUpdateStruct::class),
106		];
107
108		$updatedUserGroup = $this->createMock(UserGroup::class);
109		$eventUpdatedUserGroup = $this->createMock(UserGroup::class);
110		$innerServiceMock = $this->createMock(UserServiceInterface::class);
111		$innerServiceMock->method('updateUserGroup')->willReturn($updatedUserGroup);
112
113		$traceableEventDispatcher->addListener(UserEvents::BEFORE_UPDATE_USER_GROUP, function (BeforeUpdateUserGroupEvent $event) use ($eventUpdatedUserGroup) {
114		$event->setUpdatedUserGroup($eventUpdatedUserGroup);
115		$event->stopPropagation();
116		}, 10);
117
118		$service = new UserService($innerServiceMock, $traceableEventDispatcher);
119		$result = $service->updateUserGroup(...$parameters);
120
121		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
122		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
123
124		$this->assertSame($eventUpdatedUserGroup, $result);
125		$this->assertSame($calledListeners, [
126		[UserEvents::BEFORE_UPDATE_USER_GROUP, 10],
127		]);
128		$this->assertSame($notCalledListeners, [
129		[UserEvents::UPDATE_USER_GROUP, 0],
130		[UserEvents::BEFORE_UPDATE_USER_GROUP, 0],
131		]);
132		}
133
134		public function testUpdateUserEvents()
135		{
		@@ 198-234 (lines=37) @@
195		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
196		}
197
198		public function testUpdateUserStopPropagationInBeforeEvents()
199		{
200		$traceableEventDispatcher = $this->getEventDispatcher(
201		UserEvents::BEFORE_UPDATE_USER,
202		UserEvents::UPDATE_USER
203		);
204
205		$parameters = [
206		$this->createMock(User::class),
207		$this->createMock(UserUpdateStruct::class),
208		];
209
210		$updatedUser = $this->createMock(User::class);
211		$eventUpdatedUser = $this->createMock(User::class);
212		$innerServiceMock = $this->createMock(UserServiceInterface::class);
213		$innerServiceMock->method('updateUser')->willReturn($updatedUser);
214
215		$traceableEventDispatcher->addListener(UserEvents::BEFORE_UPDATE_USER, function (BeforeUpdateUserEvent $event) use ($eventUpdatedUser) {
216		$event->setUpdatedUser($eventUpdatedUser);
217		$event->stopPropagation();
218		}, 10);
219
220		$service = new UserService($innerServiceMock, $traceableEventDispatcher);
221		$result = $service->updateUser(...$parameters);
222
223		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
224		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
225
226		$this->assertSame($eventUpdatedUser, $result);
227		$this->assertSame($calledListeners, [
228		[UserEvents::BEFORE_UPDATE_USER, 10],
229		]);
230		$this->assertSame($notCalledListeners, [
231		[UserEvents::UPDATE_USER, 0],
232		[UserEvents::BEFORE_UPDATE_USER, 0],
233		]);
234		}
235
236		public function testUnAssignUserFromUserGroupEvents()
237		{
		@@ 777-813 (lines=37) @@
774		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
775		}
776
777		public function testCreateUserGroupStopPropagationInBeforeEvents()
778		{
779		$traceableEventDispatcher = $this->getEventDispatcher(
780		UserEvents::BEFORE_CREATE_USER_GROUP,
781		UserEvents::CREATE_USER_GROUP
782		);
783
784		$parameters = [
785		$this->createMock(UserGroupCreateStruct::class),
786		$this->createMock(UserGroup::class),
787		];
788
789		$userGroup = $this->createMock(UserGroup::class);
790		$eventUserGroup = $this->createMock(UserGroup::class);
791		$innerServiceMock = $this->createMock(UserServiceInterface::class);
792		$innerServiceMock->method('createUserGroup')->willReturn($userGroup);
793
794		$traceableEventDispatcher->addListener(UserEvents::BEFORE_CREATE_USER_GROUP, function (BeforeCreateUserGroupEvent $event) use ($eventUserGroup) {
795		$event->setUserGroup($eventUserGroup);
796		$event->stopPropagation();
797		}, 10);
798
799		$service = new UserService($innerServiceMock, $traceableEventDispatcher);
800		$result = $service->createUserGroup(...$parameters);
801
802		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
803		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
804
805		$this->assertSame($eventUserGroup, $result);
806		$this->assertSame($calledListeners, [
807		[UserEvents::BEFORE_CREATE_USER_GROUP, 10],
808		]);
809		$this->assertSame($notCalledListeners, [
810		[UserEvents::CREATE_USER_GROUP, 0],
811		[UserEvents::BEFORE_CREATE_USER_GROUP, 0],
812		]);
813		}
814
815		public function testUpdateUserTokenEvents()
816		{
		@@ 879-915 (lines=37) @@
876		$this->assertSame([], $traceableEventDispatcher->getNotCalledListeners());
877		}
878
879		public function testUpdateUserTokenStopPropagationInBeforeEvents()
880		{
881		$traceableEventDispatcher = $this->getEventDispatcher(
882		UserEvents::BEFORE_UPDATE_USER_TOKEN,
883		UserEvents::UPDATE_USER_TOKEN
884		);
885
886		$parameters = [
887		$this->createMock(User::class),
888		$this->createMock(UserTokenUpdateStruct::class),
889		];
890
891		$updatedUser = $this->createMock(User::class);
892		$eventUpdatedUser = $this->createMock(User::class);
893		$innerServiceMock = $this->createMock(UserServiceInterface::class);
894		$innerServiceMock->method('updateUserToken')->willReturn($updatedUser);
895
896		$traceableEventDispatcher->addListener(UserEvents::BEFORE_UPDATE_USER_TOKEN, function (BeforeUpdateUserTokenEvent $event) use ($eventUpdatedUser) {
897		$event->setUpdatedUser($eventUpdatedUser);
898		$event->stopPropagation();
899		}, 10);
900
901		$service = new UserService($innerServiceMock, $traceableEventDispatcher);
902		$result = $service->updateUserToken(...$parameters);
903
904		$calledListeners = $this->getListenersStack($traceableEventDispatcher->getCalledListeners());
905		$notCalledListeners = $this->getListenersStack($traceableEventDispatcher->getNotCalledListeners());
906
907		$this->assertSame($eventUpdatedUser, $result);
908		$this->assertSame($calledListeners, [
909		[UserEvents::BEFORE_UPDATE_USER_TOKEN, 10],
910		]);
911		$this->assertSame($notCalledListeners, [
912		[UserEvents::UPDATE_USER_TOKEN, 0],
913		[UserEvents::BEFORE_UPDATE_USER_TOKEN, 0],
914		]);
915		}
916		}
917

ezsystems / ezpublish-kernel

Code Duplication Length = 37-38 lines in 26 locations

eZ/Publish/Core/Event/Tests/ContentServiceTest.php 5 locations

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

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

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

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

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

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

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

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