SspAssetToCompanyBusinessUnitWritePublisherPluginTest::testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssig() - Code Metrics - Inspection of "FRW-10901 Implement MultiProcessRunConsole (#11756..." - spryker/spryker-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 60a4ae...29fcc8 )

unknown

created 2025-08-28 14:42 UTC

testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssig() A

↳ Parent: SspAssetToCompanyBusinessUnitWritePublisherPluginTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	53
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	31
nc	1
nop	0
dl	0
loc	53
rs	9.424
c	1
b	0
f	0

How to fix Long Method

<?php

/**
 * Copyright © 2016-present Spryker Systems GmbH. All rights reserved.
 * Use of this software requires acceptance of the Evaluation License Agreement. See LICENSE file.
 */

declare(strict_types=1);

namespace SprykerFeatureTest\Zed\SelfServicePortal\Communication\Plugin\Publisher\SspAsset\Search;

use Codeception\Test\Unit;
use Generated\Shared\Search\SspAssetIndexMap;
use Generated\Shared\Transfer\CompanyBusinessUnitTransfer;
use Generated\Shared\Transfer\EventEntityTransfer;
use Generated\Shared\Transfer\SspAssetBusinessUnitAssignmentTransfer;
use Generated\Shared\Transfer\SspAssetTransfer;
use Generated\Shared\Transfer\StoreTransfer;
use Orm\Zed\SelfServicePortal\Persistence\SpySspAssetSearchQuery;
use Spryker\Client\Kernel\Container;
use Spryker\Client\Queue\QueueDependencyProvider;
use Spryker\Zed\Store\Business\StoreFacadeInterface;
use Spryker\Zed\Store\StoreDependencyProvider;
use SprykerFeature\Shared\SelfServicePortal\SelfServicePortalConfig;
use SprykerFeature\Zed\SelfServicePortal\Communication\Plugin\Publisher\SspAsset\Search\SspAssetToCompanyBusinessUnitWritePublisherPlugin;
use SprykerFeature\Zed\SelfServicePortal\SelfServicePortalDependencyProvider;
use SprykerFeatureTest\Zed\SelfServicePortal\SelfServicePortalCommunicationTester;

/**
 * @group SprykerFeatureTest
 * @group Zed
 * @group SelfServicePortal
 * @group Communication
 * @group Plugin
 * @group Publisher
 * @group SspAssetToCompanyBusinessUnitWritePublisherPluginTest
 */
class SspAssetToCompanyBusinessUnitWritePublisherPluginTest extends Unit
{
    /**
     * @var string
     */
    protected const STORE_NAME_AT = 'AT';

    /**
     * @var string
     */
    protected const STORE_NAME_DE = 'DE';

    /**
     * @uses \Orm\Zed\SelfServicePortal\Persistence\Map\SpySspAssetToCompanyBusinessUnitTableMap::COL_FK_SSP_ASSET
     *
     * @var string
     */
    protected const COL_FK_SSP_ASSET = 'spy_ssp_asset_to_company_business_unit.fk_ssp_asset';

    /**
     * @uses \Orm\Zed\SelfServicePortal\Persistence\Map\SpySspAssetToCompanyBusinessUnitTableMap::COL_FK_COMPANY_BUSINESS_UNIT
     *
     * @var string
     */
    protected const COL_FK_COMPANY_BUSINESS_UNIT = 'spy_ssp_asset_to_company_business_unit.fk_company_business_unit';

    protected SelfServicePortalCommunicationTester $tester;

    protected function setUp(): void
    {
        parent::setUp();

        $storeTransferAT = $this->tester->haveStore([
            StoreTransfer::NAME => static::STORE_NAME_AT,
        ]);

        $storeTransferDE = $this->tester->haveStore([
            StoreTransfer::NAME => static::STORE_NAME_DE,
        ]);

        $storeFacadeMock = $this->createMock(StoreFacadeInterface::class);
        $storeFacadeMock->method('getAllStores')->willReturn([
            $storeTransferAT,
            $storeTransferDE,
        ]);

        $this->tester->setDependency(
            SelfServicePortalDependencyProvider::FACADE_STORE,
            $storeFacadeMock,
        );

        $this->tester->setDependency(
            QueueDependencyProvider::QUEUE_ADAPTERS,
            function (Container $container) {
                return [
                    $container->getLocator()->rabbitMq()->client()->createQueueAdapter(),
                ];
            },
        );

        $this->tester->setDependency(
            StoreDependencyProvider::SERVICE_STORE,
            static::STORE_NAME_DE,
        );

        $this->tester->ensureSspAssetRelatedTablesAreEmpty();
    }

    public function testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssignmentCreate(): void
    {
        // Arrange
        $companyTransfer1 = $this->tester->haveCompany();
        $companyTransfer2 = $this->tester->haveCompany();

        $businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
        ]);

        $businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
        ]);

        $sspAssetTransfer = $this->tester->haveAsset([
            SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
            SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
                [SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
            ],
        ]);

        // Act
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
            [
                (new EventEntityTransfer())
                    ->setForeignKeys([
                        static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
                        static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer2->getIdCompanyBusinessUnit(),
                    ]),
            ],
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
        );

        // Assert
        $sspAssetSearchEntity = SpySspAssetSearchQuery::create()
            ->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
            ->findOne();

        $this->assertNotNull($sspAssetSearchEntity);
        $this->assertSame($sspAssetTransfer->getIdSspAsset(), $sspAssetSearchEntity->getFkSspAsset());

        $searchData = $sspAssetSearchEntity->getData();
        $this->assertArrayHasKey(SspAssetIndexMap::SEARCH_RESULT_DATA, $searchData);

        $resultData = $searchData[SspAssetIndexMap::SEARCH_RESULT_DATA];
        $this->assertArrayHasKey('business_unit_ids', $resultData);
        $this->assertContains($businessUnitTransfer1->getIdCompanyBusinessUnit(), $resultData['business_unit_ids']);

        $this->assertArrayHasKey('company_ids', $resultData);
        $this->assertContains($companyTransfer1->getIdCompany(), $resultData['company_ids']);
    }

    public function testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssignmentDelete(): void
    {
        // Arrange
        $companyTransfer1 = $this->tester->haveCompany();
        $companyTransfer2 = $this->tester->haveCompany();

        $businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
        ]);

        $businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
        ]);

        $sspAssetTransfer = $this->tester->haveAsset([
            SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
            SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
                [SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
                [SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2],
            ],
        ]);

        $this->tester->haveSspAssetSearch([
            'fk_ssp_asset' => $sspAssetTransfer->getIdSspAsset(),
            'data' => '{"type":"ssp_asset","name":"A1","store":"DE"}',
            'structured_data' => '{"type":"ssp_asset","name":"A1","store":"DE"}',
            'key' => 'key:1',
        ]);

        $this->tester->ensureSspAssetRelatedTablesAreEmpty();

        // Act
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
            [
                (new EventEntityTransfer())
                    ->setForeignKeys([
                        static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
                        static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer2->getIdCompanyBusinessUnit(),
                    ]),
            ],
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_DELETE,
        );

        // Assert
        $sspAssetSearchEntity = SpySspAssetSearchQuery::create()
            ->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
            ->findOne();

        $this->assertNull($sspAssetSearchEntity);
    }

    public function testHandleBulkUpdatesOwnerBusinessUnitAndCompanyInformation(): void
    {
        // Arrange
        $companyTransfer = $this->tester->haveCompany();
        $businessUnitTransfer = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer,
        ]);

        $additionalBusinessUnitTransfer = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer,
        ]);

        $sspAssetTransfer = $this->tester->haveAsset([
            SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer,
            SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
                [SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer],
            ],
        ]);

        // Act
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
            [
                (new EventEntityTransfer())
                    ->setForeignKeys([
                        static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
                        static::COL_FK_COMPANY_BUSINESS_UNIT => $additionalBusinessUnitTransfer->getIdCompanyBusinessUnit(),
                    ]),
            ],
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
        );

        // Assert
        $sspAssetSearchEntity = SpySspAssetSearchQuery::create()
            ->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
            ->findOne();

        $this->assertNotNull($sspAssetSearchEntity);

        $searchData = $sspAssetSearchEntity->getData();
        $this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT, $searchData);
        $this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_COMPANY_ID, $searchData);

        $this->assertSame($businessUnitTransfer->getIdCompanyBusinessUnit(), $searchData[SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT]);
        $this->assertSame($companyTransfer->getIdCompany(), $searchData[SspAssetIndexMap::ID_OWNER_COMPANY_ID]);

        $this->assertArrayHasKey(SspAssetIndexMap::BUSINESS_UNIT_IDS, $searchData);
        $this->assertArrayHasKey(SspAssetIndexMap::COMPANY_IDS, $searchData);

        $this->assertContains($businessUnitTransfer->getIdCompanyBusinessUnit(), $searchData[SspAssetIndexMap::BUSINESS_UNIT_IDS]);
        $this->assertContains($companyTransfer->getIdCompany(), $searchData[SspAssetIndexMap::COMPANY_IDS]);
    }

    public function testHandleBulkWithMultipleEventEntityTransfers(): void
    {
        // Arrange
        $companyTransfer1 = $this->tester->haveCompany();
        $companyTransfer2 = $this->tester->haveCompany();

        $businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
        ]);

        $businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
        ]);

        $businessUnitTransfer3 = $this->tester->haveCompanyBusinessUnit([
            CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
            CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
        ]);

        $sspAssetTransfer1 = $this->tester->haveAsset([
            SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
            SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
                [SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
            ],
        ]);

        $sspAssetTransfer2 = $this->tester->haveAsset([
            SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2,
            SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
                [SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2],
            ],
        ]);

        // Act
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
            [
                (new EventEntityTransfer())
                    ->setForeignKeys([
                        static::COL_FK_SSP_ASSET => $sspAssetTransfer1->getIdSspAsset(),
                        static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer3->getIdCompanyBusinessUnit(),
                    ]),
                (new EventEntityTransfer())
                    ->setForeignKeys([
                        static::COL_FK_SSP_ASSET => $sspAssetTransfer2->getIdSspAsset(),
                        static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer1->getIdCompanyBusinessUnit(),
                    ]),
            ],
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
        );

        // Assert
        $sspAssetSearchEntities = SpySspAssetSearchQuery::create()
            ->filterByFkSspAsset_In([
                $sspAssetTransfer1->getIdSspAsset(),
                $sspAssetTransfer2->getIdSspAsset(),
            ])
            ->orderByFkSspAsset()
            ->find();

        $this->assertCount(2, $sspAssetSearchEntities);

        $sspAssetSearchEntity1 = $sspAssetSearchEntities[0];
        $sspAssetSearchEntity2 = $sspAssetSearchEntities[1];

        $this->assertSame($sspAssetTransfer1->getIdSspAsset(), $sspAssetSearchEntity1->getFkSspAsset());
        $this->assertSame($sspAssetTransfer2->getIdSspAsset(), $sspAssetSearchEntity2->getFkSspAsset());

        $this->assertSearchDataStructure($sspAssetSearchEntity1->getData());
        $this->assertSearchDataStructure($sspAssetSearchEntity2->getData());
    }

    public function testHandleBulkWithEmptyEventEntityTransfers(): void
    {
        // Arrange
        $this->tester->ensureSspAssetSearchTableIsEmpty();

        // Act
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
            [],
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
        );

        // Assert
        $sspAssetSearchEntities = SpySspAssetSearchQuery::create()->find();
        $this->assertCount(0, $sspAssetSearchEntities);
    }

    public function testGetSubscribedEventsReturnsCorrectEvents(): void
    {
        // Arrange
        $sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();

        // Act
        $subscribedEvents = $sspAssetToCompanyBusinessUnitWritePublisherPlugin->getSubscribedEvents();

        $expectedEvents = [
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_UPDATE,
            SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_DELETE,
        ];

        // Assert
        $this->assertSame($expectedEvents, $subscribedEvents);
    }

    /**
     * @param array<string, mixed> $data
     *
     * @return void
     */
    protected function assertSearchDataStructure(array $data): void
    {
        $this->assertArrayHasKey(SspAssetIndexMap::TYPE, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::SEARCH_RESULT_DATA, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::FULL_TEXT_BOOSTED, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::SUGGESTION_TERMS, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::COMPLETION_TERMS, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::STORE, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::BUSINESS_UNIT_IDS, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::COMPANY_IDS, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT, $data);
        $this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_COMPANY_ID, $data);

        $this->assertSame(SelfServicePortalConfig::SSP_ASSET_RESOURCE_NAME, $data[SspAssetIndexMap::TYPE]);
        $this->assertSame([static::STORE_NAME_AT, static::STORE_NAME_DE], $data[SspAssetIndexMap::STORE]);
    }
}


1			<?php
2
3			/**
4			* Copyright © 2016-present Spryker Systems GmbH. All rights reserved.
5			* Use of this software requires acceptance of the Evaluation License Agreement. See LICENSE file.
6			*/
7
8			declare(strict_types=1);
9
10			namespace SprykerFeatureTest\Zed\SelfServicePortal\Communication\Plugin\Publisher\SspAsset\Search;
11
12			use Codeception\Test\Unit;
13			use Generated\Shared\Search\SspAssetIndexMap;
14			use Generated\Shared\Transfer\CompanyBusinessUnitTransfer;
15			use Generated\Shared\Transfer\EventEntityTransfer;
16			use Generated\Shared\Transfer\SspAssetBusinessUnitAssignmentTransfer;
17			use Generated\Shared\Transfer\SspAssetTransfer;
18			use Generated\Shared\Transfer\StoreTransfer;
19			use Orm\Zed\SelfServicePortal\Persistence\SpySspAssetSearchQuery;
20			use Spryker\Client\Kernel\Container;
21			use Spryker\Client\Queue\QueueDependencyProvider;
22			use Spryker\Zed\Store\Business\StoreFacadeInterface;
23			use Spryker\Zed\Store\StoreDependencyProvider;
24			use SprykerFeature\Shared\SelfServicePortal\SelfServicePortalConfig;
25			use SprykerFeature\Zed\SelfServicePortal\Communication\Plugin\Publisher\SspAsset\Search\SspAssetToCompanyBusinessUnitWritePublisherPlugin;
26			use SprykerFeature\Zed\SelfServicePortal\SelfServicePortalDependencyProvider;
27			use SprykerFeatureTest\Zed\SelfServicePortal\SelfServicePortalCommunicationTester;
28
29			/**
30			* @group SprykerFeatureTest
31			* @group Zed
32			* @group SelfServicePortal
33			* @group Communication
34			* @group Plugin
35			* @group Publisher
36			* @group SspAssetToCompanyBusinessUnitWritePublisherPluginTest
37			*/
38			class SspAssetToCompanyBusinessUnitWritePublisherPluginTest extends Unit
39			{
40			/**
41			* @var string
42			*/
43			protected const STORE_NAME_AT = 'AT';
44
45			/**
46			* @var string
47			*/
48			protected const STORE_NAME_DE = 'DE';
49
50			/**
51			* @uses \Orm\Zed\SelfServicePortal\Persistence\Map\SpySspAssetToCompanyBusinessUnitTableMap::COL_FK_SSP_ASSET
52			*
53			* @var string
54			*/
55			protected const COL_FK_SSP_ASSET = 'spy_ssp_asset_to_company_business_unit.fk_ssp_asset';
56
57			/**
58			* @uses \Orm\Zed\SelfServicePortal\Persistence\Map\SpySspAssetToCompanyBusinessUnitTableMap::COL_FK_COMPANY_BUSINESS_UNIT
59			*
60			* @var string
61			*/
62			protected const COL_FK_COMPANY_BUSINESS_UNIT = 'spy_ssp_asset_to_company_business_unit.fk_company_business_unit';
63
64			protected SelfServicePortalCommunicationTester $tester;
65
66			protected function setUp(): void
67			{
68			parent::setUp();
69
70			$storeTransferAT = $this->tester->haveStore([
71			StoreTransfer::NAME => static::STORE_NAME_AT,
72			]);
73
74			$storeTransferDE = $this->tester->haveStore([
75			StoreTransfer::NAME => static::STORE_NAME_DE,
76			]);
77
78			$storeFacadeMock = $this->createMock(StoreFacadeInterface::class);
79			$storeFacadeMock->method('getAllStores')->willReturn([
80			$storeTransferAT,
81			$storeTransferDE,
82			]);
83
84			$this->tester->setDependency(
85			SelfServicePortalDependencyProvider::FACADE_STORE,
86			$storeFacadeMock,
87			);
88
89			$this->tester->setDependency(
90			QueueDependencyProvider::QUEUE_ADAPTERS,
91			function (Container $container) {
92			return [
93			$container->getLocator()->rabbitMq()->client()->createQueueAdapter(),
94			];
95			},
96			);
97
98			$this->tester->setDependency(
99			StoreDependencyProvider::SERVICE_STORE,
100			static::STORE_NAME_DE,
101			);
102
103			$this->tester->ensureSspAssetRelatedTablesAreEmpty();
104			}
105
106			public function testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssignmentCreate(): void
107			{
108			// Arrange
109			$companyTransfer1 = $this->tester->haveCompany();
110			$companyTransfer2 = $this->tester->haveCompany();
111
112			$businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
113			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
114			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
115			]);
116
117			$businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
118			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
119			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
120			]);
121
122			$sspAssetTransfer = $this->tester->haveAsset([
123			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
124			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
125			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
126			],
127			]);
128
129			// Act
130			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
131			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
132			[
133			(new EventEntityTransfer())
134			->setForeignKeys([
135			static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
136			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer2->getIdCompanyBusinessUnit(),
137			]),
138			],
139			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
140			);
141
142			// Assert
143			$sspAssetSearchEntity = SpySspAssetSearchQuery::create()
144			->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
145			->findOne();
146
147			$this->assertNotNull($sspAssetSearchEntity);
148			$this->assertSame($sspAssetTransfer->getIdSspAsset(), $sspAssetSearchEntity->getFkSspAsset());
149
150			$searchData = $sspAssetSearchEntity->getData();
151			$this->assertArrayHasKey(SspAssetIndexMap::SEARCH_RESULT_DATA, $searchData);
152
153			$resultData = $searchData[SspAssetIndexMap::SEARCH_RESULT_DATA];
154			$this->assertArrayHasKey('business_unit_ids', $resultData);
155			$this->assertContains($businessUnitTransfer1->getIdCompanyBusinessUnit(), $resultData['business_unit_ids']);
156
157			$this->assertArrayHasKey('company_ids', $resultData);
158			$this->assertContains($companyTransfer1->getIdCompany(), $resultData['company_ids']);
159			}
160
161			public function testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssignmentDelete(): void
162			{
163			// Arrange
164			$companyTransfer1 = $this->tester->haveCompany();
165			$companyTransfer2 = $this->tester->haveCompany();
166
167			$businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
168			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
169			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
170			]);
171
172			$businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
173			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
174			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
175			]);
176
177			$sspAssetTransfer = $this->tester->haveAsset([
178			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
179			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
180			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
181			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2],
182			],
183			]);
184
185			$this->tester->haveSspAssetSearch([
186			'fk_ssp_asset' => $sspAssetTransfer->getIdSspAsset(),
187			'data' => '{"type":"ssp_asset","name":"A1","store":"DE"}',
188			'structured_data' => '{"type":"ssp_asset","name":"A1","store":"DE"}',
189			'key' => 'key:1',
190			]);
191
192			$this->tester->ensureSspAssetRelatedTablesAreEmpty();
193
194			// Act
195			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
196			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
197			[
198			(new EventEntityTransfer())
199			->setForeignKeys([
200			static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
201			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer2->getIdCompanyBusinessUnit(),
202			]),
203			],
204			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_DELETE,
205			);
206
207			// Assert
208			$sspAssetSearchEntity = SpySspAssetSearchQuery::create()
209			->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
210			->findOne();
211
212			$this->assertNull($sspAssetSearchEntity);
213			}
214
215			public function testHandleBulkUpdatesOwnerBusinessUnitAndCompanyInformation(): void
216			{
217			// Arrange
218			$companyTransfer = $this->tester->haveCompany();
219			$businessUnitTransfer = $this->tester->haveCompanyBusinessUnit([
220			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer->getIdCompany(),
221			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer,
222			]);
223
224			$additionalBusinessUnitTransfer = $this->tester->haveCompanyBusinessUnit([
225			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer->getIdCompany(),
226			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer,
227			]);
228
229			$sspAssetTransfer = $this->tester->haveAsset([
230			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer,
231			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
232			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer],
233			],
234			]);
235
236			// Act
237			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
238			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
239			[
240			(new EventEntityTransfer())
241			->setForeignKeys([
242			static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
243			static::COL_FK_COMPANY_BUSINESS_UNIT => $additionalBusinessUnitTransfer->getIdCompanyBusinessUnit(),
244			]),
245			],
246			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
247			);
248
249			// Assert
250			$sspAssetSearchEntity = SpySspAssetSearchQuery::create()
251			->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
252			->findOne();
253
254			$this->assertNotNull($sspAssetSearchEntity);
255
256			$searchData = $sspAssetSearchEntity->getData();
257			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT, $searchData);
258			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_COMPANY_ID, $searchData);
259
260			$this->assertSame($businessUnitTransfer->getIdCompanyBusinessUnit(), $searchData[SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT]);
261			$this->assertSame($companyTransfer->getIdCompany(), $searchData[SspAssetIndexMap::ID_OWNER_COMPANY_ID]);
262
263			$this->assertArrayHasKey(SspAssetIndexMap::BUSINESS_UNIT_IDS, $searchData);
264			$this->assertArrayHasKey(SspAssetIndexMap::COMPANY_IDS, $searchData);
265
266			$this->assertContains($businessUnitTransfer->getIdCompanyBusinessUnit(), $searchData[SspAssetIndexMap::BUSINESS_UNIT_IDS]);
267			$this->assertContains($companyTransfer->getIdCompany(), $searchData[SspAssetIndexMap::COMPANY_IDS]);
268			}
269
270			public function testHandleBulkWithMultipleEventEntityTransfers(): void
271			{
272			// Arrange
273			$companyTransfer1 = $this->tester->haveCompany();
274			$companyTransfer2 = $this->tester->haveCompany();
275
276			$businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
277			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
278			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
279			]);
280
281			$businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
282			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
283			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
284			]);
285
286			$businessUnitTransfer3 = $this->tester->haveCompanyBusinessUnit([
287			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
288			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
289			]);
290
291			$sspAssetTransfer1 = $this->tester->haveAsset([
292			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
293			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
294			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
295			],
296			]);
297
298			$sspAssetTransfer2 = $this->tester->haveAsset([
299			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2,
300			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
301			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2],
302			],
303			]);
304
305			// Act
306			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
307			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
308			[
309			(new EventEntityTransfer())
310			->setForeignKeys([
311			static::COL_FK_SSP_ASSET => $sspAssetTransfer1->getIdSspAsset(),
312			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer3->getIdCompanyBusinessUnit(),
313			]),
314			(new EventEntityTransfer())
315			->setForeignKeys([
316			static::COL_FK_SSP_ASSET => $sspAssetTransfer2->getIdSspAsset(),
317			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer1->getIdCompanyBusinessUnit(),
318			]),
319			],
320			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
321			);
322
323			// Assert
324			$sspAssetSearchEntities = SpySspAssetSearchQuery::create()
325			->filterByFkSspAsset_In([
326			$sspAssetTransfer1->getIdSspAsset(),
327			$sspAssetTransfer2->getIdSspAsset(),
328			])
329			->orderByFkSspAsset()
330			->find();
331
332			$this->assertCount(2, $sspAssetSearchEntities);
333
334			$sspAssetSearchEntity1 = $sspAssetSearchEntities[0];
335			$sspAssetSearchEntity2 = $sspAssetSearchEntities[1];
336
337			$this->assertSame($sspAssetTransfer1->getIdSspAsset(), $sspAssetSearchEntity1->getFkSspAsset());
338			$this->assertSame($sspAssetTransfer2->getIdSspAsset(), $sspAssetSearchEntity2->getFkSspAsset());
339
340			$this->assertSearchDataStructure($sspAssetSearchEntity1->getData());
341			$this->assertSearchDataStructure($sspAssetSearchEntity2->getData());
342			}
343
344			public function testHandleBulkWithEmptyEventEntityTransfers(): void
345			{
346			// Arrange
347			$this->tester->ensureSspAssetSearchTableIsEmpty();
348
349			// Act
350			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
351			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
352			[],
353			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
354			);
355
356			// Assert
357			$sspAssetSearchEntities = SpySspAssetSearchQuery::create()->find();
358			$this->assertCount(0, $sspAssetSearchEntities);
359			}
360
361			public function testGetSubscribedEventsReturnsCorrectEvents(): void
362			{
363			// Arrange
364			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
365
366			// Act
367			$subscribedEvents = $sspAssetToCompanyBusinessUnitWritePublisherPlugin->getSubscribedEvents();
368
369			$expectedEvents = [
370			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
371			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_UPDATE,
372			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_DELETE,
373			];
374
375			// Assert
376			$this->assertSame($expectedEvents, $subscribedEvents);
377			}
378
379			/**
380			* @param array<string, mixed> $data
381			*
382			* @return void
383			*/
384			protected function assertSearchDataStructure(array $data): void
385			{
386			$this->assertArrayHasKey(SspAssetIndexMap::TYPE, $data);
387			$this->assertArrayHasKey(SspAssetIndexMap::SEARCH_RESULT_DATA, $data);
388			$this->assertArrayHasKey(SspAssetIndexMap::FULL_TEXT_BOOSTED, $data);
389			$this->assertArrayHasKey(SspAssetIndexMap::SUGGESTION_TERMS, $data);
390			$this->assertArrayHasKey(SspAssetIndexMap::COMPLETION_TERMS, $data);
391			$this->assertArrayHasKey(SspAssetIndexMap::STORE, $data);
392			$this->assertArrayHasKey(SspAssetIndexMap::BUSINESS_UNIT_IDS, $data);
393			$this->assertArrayHasKey(SspAssetIndexMap::COMPANY_IDS, $data);
394			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT, $data);
395			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_COMPANY_ID, $data);
396
397			$this->assertSame(SelfServicePortalConfig::SSP_ASSET_RESOURCE_NAME, $data[SspAssetIndexMap::TYPE]);
398			$this->assertSame([static::STORE_NAME_AT, static::STORE_NAME_DE], $data[SspAssetIndexMap::STORE]);
399			}
400			}
401

spryker / spryker-core

Push — master ( 60a4ae...29fcc8 )

testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssig() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like