SspAssetToCompanyBusinessUnitWritePublisherPluginTest::setUp() - Code Metrics - Inspection of "FRW-10578: Publish performance improvements (#1165..." - spryker/spryker-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cacbf1...74b6c9 )

unknown

created 2025-08-21 15:13 UTC

setUp() A

↳ Parent: SspAssetToCompanyBusinessUnitWritePublisherPluginTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	19
nc	1
nop	0
dl	0
loc	32
rs	9.6333
c	1
b	0
f	0

<?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_UF = 'UF';

    /**
     * @var string
     */
    protected const STORE_NAME_LO = 'LO';

    /**
     * @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();

        $storeFacadeMock = $this->createMock(StoreFacadeInterface::class);
        $storeFacadeMock->method('getAllStores')->willReturn([
            (new StoreTransfer())->setName(static::STORE_NAME_UF),
            (new StoreTransfer())->setName(static::STORE_NAME_LO),
        ]);

        $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_UF,
        );

        $this->tester->ensureSspAssetToCompanyBusinessUnitTableIsEmpty();
        $this->tester->ensureSspAssetToSspModelTableIsEmpty();
        $this->tester->ensureSspAssetTableIsEmpty();
    }

    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('busines_unit_ids', $resultData);
        $this->assertContains($businessUnitTransfer1->getIdCompanyBusinessUnit(), $resultData['busines_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":"UF"}',
             'structured_data' => '{"type":"ssp_asset","name":"A1","store":"UF"}',
             'key' => 'key:1',
         ]);

        $this->tester->ensureSspAssetToCompanyBusinessUnitTableIsEmpty();
        $this->tester->ensureSspAssetToSspModelTableIsEmpty();
        $this->tester->ensureSspAssetTableIsEmpty();

        // 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_UF, static::STORE_NAME_LO], $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_UF = 'UF';
44
45			/**
46			* @var string
47			*/
48			protected const STORE_NAME_LO = 'LO';
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			$storeFacadeMock = $this->createMock(StoreFacadeInterface::class);
71			$storeFacadeMock->method('getAllStores')->willReturn([
72			(new StoreTransfer())->setName(static::STORE_NAME_UF),
73			(new StoreTransfer())->setName(static::STORE_NAME_LO),
74			]);
75
76			$this->tester->setDependency(
77			SelfServicePortalDependencyProvider::FACADE_STORE,
78			$storeFacadeMock,
79			);
80
81			$this->tester->setDependency(
82			QueueDependencyProvider::QUEUE_ADAPTERS,
83			function (Container $container) {
84			return [
85			$container->getLocator()->rabbitMq()->client()->createQueueAdapter(),
86			];
87			},
88			);
89
90			$this->tester->setDependency(
91			StoreDependencyProvider::SERVICE_STORE,
92			static::STORE_NAME_UF,
93			);
94
95			$this->tester->ensureSspAssetToCompanyBusinessUnitTableIsEmpty();
96			$this->tester->ensureSspAssetToSspModelTableIsEmpty();
97			$this->tester->ensureSspAssetTableIsEmpty();
98			}
99
100			public function testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssignmentCreate(): void
101			{
102			// Arrange
103			$companyTransfer1 = $this->tester->haveCompany();
104			$companyTransfer2 = $this->tester->haveCompany();
105
106			$businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
107			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
108			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
109			]);
110
111			$businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
112			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
113			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
114			]);
115
116			$sspAssetTransfer = $this->tester->haveAsset([
117			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
118			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
119			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
120			],
121			]);
122
123			// Act
124			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
125			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
126			[
127			(new EventEntityTransfer())
128			->setForeignKeys([
129			static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
130			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer2->getIdCompanyBusinessUnit(),
131			]),
132			],
133			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
134			);
135
136			// Assert
137			$sspAssetSearchEntity = SpySspAssetSearchQuery::create()
138			->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
139			->findOne();
140
141			$this->assertNotNull($sspAssetSearchEntity);
142			$this->assertSame($sspAssetTransfer->getIdSspAsset(), $sspAssetSearchEntity->getFkSspAsset());
143
144			$searchData = $sspAssetSearchEntity->getData();
145			$this->assertArrayHasKey(SspAssetIndexMap::SEARCH_RESULT_DATA, $searchData);
146
147			$resultData = $searchData[SspAssetIndexMap::SEARCH_RESULT_DATA];
148			$this->assertArrayHasKey('busines_unit_ids', $resultData);
149			$this->assertContains($businessUnitTransfer1->getIdCompanyBusinessUnit(), $resultData['busines_unit_ids']);
150
151			$this->assertArrayHasKey('company_ids', $resultData);
152			$this->assertContains($companyTransfer1->getIdCompany(), $resultData['company_ids']);
153			}
154
155			public function testHandleBulkWritesSspAssetSearchDataOnBusinessUnitAssignmentDelete(): void
156			{
157			// Arrange
158			$companyTransfer1 = $this->tester->haveCompany();
159			$companyTransfer2 = $this->tester->haveCompany();
160
161			$businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
162			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
163			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
164			]);
165
166			$businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
167			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
168			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
169			]);
170
171			$sspAssetTransfer = $this->tester->haveAsset([
172			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
173			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
174			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
175			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2],
176			],
177			]);
178
179			$this->tester->haveSspAssetSearch([
180			'fk_ssp_asset' => $sspAssetTransfer->getIdSspAsset(),
181			'data' => '{"type":"ssp_asset","name":"A1","store":"UF"}',
182			'structured_data' => '{"type":"ssp_asset","name":"A1","store":"UF"}',
183			'key' => 'key:1',
184			]);
185
186			$this->tester->ensureSspAssetToCompanyBusinessUnitTableIsEmpty();
187			$this->tester->ensureSspAssetToSspModelTableIsEmpty();
188			$this->tester->ensureSspAssetTableIsEmpty();
189
190			// Act
191			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
192			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
193			[
194			(new EventEntityTransfer())
195			->setForeignKeys([
196			static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
197			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer2->getIdCompanyBusinessUnit(),
198			]),
199			],
200			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_DELETE,
201			);
202
203			// Assert
204			$sspAssetSearchEntity = SpySspAssetSearchQuery::create()
205			->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
206			->findOne();
207
208			$this->assertNull($sspAssetSearchEntity);
209			}
210
211			public function testHandleBulkUpdatesOwnerBusinessUnitAndCompanyInformation(): void
212			{
213			// Arrange
214			$companyTransfer = $this->tester->haveCompany();
215			$businessUnitTransfer = $this->tester->haveCompanyBusinessUnit([
216			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer->getIdCompany(),
217			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer,
218			]);
219
220			$additionalBusinessUnitTransfer = $this->tester->haveCompanyBusinessUnit([
221			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer->getIdCompany(),
222			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer,
223			]);
224
225			$sspAssetTransfer = $this->tester->haveAsset([
226			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer,
227			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
228			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer],
229			],
230			]);
231
232			// Act
233			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
234			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
235			[
236			(new EventEntityTransfer())
237			->setForeignKeys([
238			static::COL_FK_SSP_ASSET => $sspAssetTransfer->getIdSspAsset(),
239			static::COL_FK_COMPANY_BUSINESS_UNIT => $additionalBusinessUnitTransfer->getIdCompanyBusinessUnit(),
240			]),
241			],
242			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
243			);
244
245			// Assert
246			$sspAssetSearchEntity = SpySspAssetSearchQuery::create()
247			->filterByFkSspAsset($sspAssetTransfer->getIdSspAsset())
248			->findOne();
249
250			$this->assertNotNull($sspAssetSearchEntity);
251
252			$searchData = $sspAssetSearchEntity->getData();
253			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT, $searchData);
254			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_COMPANY_ID, $searchData);
255
256			$this->assertSame($businessUnitTransfer->getIdCompanyBusinessUnit(), $searchData[SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT]);
257			$this->assertSame($companyTransfer->getIdCompany(), $searchData[SspAssetIndexMap::ID_OWNER_COMPANY_ID]);
258
259			$this->assertArrayHasKey(SspAssetIndexMap::BUSINESS_UNIT_IDS, $searchData);
260			$this->assertArrayHasKey(SspAssetIndexMap::COMPANY_IDS, $searchData);
261
262			$this->assertContains($businessUnitTransfer->getIdCompanyBusinessUnit(), $searchData[SspAssetIndexMap::BUSINESS_UNIT_IDS]);
263			$this->assertContains($companyTransfer->getIdCompany(), $searchData[SspAssetIndexMap::COMPANY_IDS]);
264			}
265
266			public function testHandleBulkWithMultipleEventEntityTransfers(): void
267			{
268			// Arrange
269			$companyTransfer1 = $this->tester->haveCompany();
270			$companyTransfer2 = $this->tester->haveCompany();
271
272			$businessUnitTransfer1 = $this->tester->haveCompanyBusinessUnit([
273			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
274			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
275			]);
276
277			$businessUnitTransfer2 = $this->tester->haveCompanyBusinessUnit([
278			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer2->getIdCompany(),
279			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer2,
280			]);
281
282			$businessUnitTransfer3 = $this->tester->haveCompanyBusinessUnit([
283			CompanyBusinessUnitTransfer::FK_COMPANY => $companyTransfer1->getIdCompany(),
284			CompanyBusinessUnitTransfer::COMPANY => $companyTransfer1,
285			]);
286
287			$sspAssetTransfer1 = $this->tester->haveAsset([
288			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1,
289			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
290			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer1],
291			],
292			]);
293
294			$sspAssetTransfer2 = $this->tester->haveAsset([
295			SspAssetTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2,
296			SspAssetTransfer::BUSINESS_UNIT_ASSIGNMENTS => [
297			[SspAssetBusinessUnitAssignmentTransfer::COMPANY_BUSINESS_UNIT => $businessUnitTransfer2],
298			],
299			]);
300
301			// Act
302			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
303			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
304			[
305			(new EventEntityTransfer())
306			->setForeignKeys([
307			static::COL_FK_SSP_ASSET => $sspAssetTransfer1->getIdSspAsset(),
308			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer3->getIdCompanyBusinessUnit(),
309			]),
310			(new EventEntityTransfer())
311			->setForeignKeys([
312			static::COL_FK_SSP_ASSET => $sspAssetTransfer2->getIdSspAsset(),
313			static::COL_FK_COMPANY_BUSINESS_UNIT => $businessUnitTransfer1->getIdCompanyBusinessUnit(),
314			]),
315			],
316			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
317			);
318
319			// Assert
320			$sspAssetSearchEntities = SpySspAssetSearchQuery::create()
321			->filterByFkSspAsset_In([
322			$sspAssetTransfer1->getIdSspAsset(),
323			$sspAssetTransfer2->getIdSspAsset(),
324			])
325			->orderByFkSspAsset()
326			->find();
327
328			$this->assertCount(2, $sspAssetSearchEntities);
329
330			$sspAssetSearchEntity1 = $sspAssetSearchEntities[0];
331			$sspAssetSearchEntity2 = $sspAssetSearchEntities[1];
332
333			$this->assertSame($sspAssetTransfer1->getIdSspAsset(), $sspAssetSearchEntity1->getFkSspAsset());
334			$this->assertSame($sspAssetTransfer2->getIdSspAsset(), $sspAssetSearchEntity2->getFkSspAsset());
335
336			$this->assertSearchDataStructure($sspAssetSearchEntity1->getData());
337			$this->assertSearchDataStructure($sspAssetSearchEntity2->getData());
338			}
339
340			public function testHandleBulkWithEmptyEventEntityTransfers(): void
341			{
342			// Arrange
343			$this->tester->ensureSspAssetSearchTableIsEmpty();
344
345			// Act
346			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
347			$sspAssetToCompanyBusinessUnitWritePublisherPlugin->handleBulk(
348			[],
349			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
350			);
351
352			// Assert
353			$sspAssetSearchEntities = SpySspAssetSearchQuery::create()->find();
354			$this->assertCount(0, $sspAssetSearchEntities);
355			}
356
357			public function testGetSubscribedEventsReturnsCorrectEvents(): void
358			{
359			// Arrange
360			$sspAssetToCompanyBusinessUnitWritePublisherPlugin = new SspAssetToCompanyBusinessUnitWritePublisherPlugin();
361
362			// Act
363			$subscribedEvents = $sspAssetToCompanyBusinessUnitWritePublisherPlugin->getSubscribedEvents();
364
365			$expectedEvents = [
366			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_CREATE,
367			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_UPDATE,
368			SelfServicePortalConfig::ENTITY_SPY_SSP_ASSET_TO_COMPANY_BUSINESS_UNIT_DELETE,
369			];
370
371			// Assert
372			$this->assertSame($expectedEvents, $subscribedEvents);
373			}
374
375			/**
376			* @param array<string, mixed> $data
377			*
378			* @return void
379			*/
380			protected function assertSearchDataStructure(array $data): void
381			{
382			$this->assertArrayHasKey(SspAssetIndexMap::TYPE, $data);
383			$this->assertArrayHasKey(SspAssetIndexMap::SEARCH_RESULT_DATA, $data);
384			$this->assertArrayHasKey(SspAssetIndexMap::FULL_TEXT_BOOSTED, $data);
385			$this->assertArrayHasKey(SspAssetIndexMap::SUGGESTION_TERMS, $data);
386			$this->assertArrayHasKey(SspAssetIndexMap::COMPLETION_TERMS, $data);
387			$this->assertArrayHasKey(SspAssetIndexMap::STORE, $data);
388			$this->assertArrayHasKey(SspAssetIndexMap::BUSINESS_UNIT_IDS, $data);
389			$this->assertArrayHasKey(SspAssetIndexMap::COMPANY_IDS, $data);
390			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_BUSINESS_UNIT, $data);
391			$this->assertArrayHasKey(SspAssetIndexMap::ID_OWNER_COMPANY_ID, $data);
392
393			$this->assertSame(SelfServicePortalConfig::SSP_ASSET_RESOURCE_NAME, $data[SspAssetIndexMap::TYPE]);
394			$this->assertSame([static::STORE_NAME_UF, static::STORE_NAME_LO], $data[SspAssetIndexMap::STORE]);
395			}
396			}
397

spryker / spryker-core

Push — master ( cacbf1...74b6c9 )

setUp() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like