randomBytes example

            $this->insertTransition($action, $machineId, $stateId, $toId, $connection);
        }
    }

    private function insertTransition(string $action, string $machineId, string $from, string $to, Connection $connection): void
    {
        $connection->executeStatement(
            'REPLACE INTO state_machine_transition (id, action_name, state_machine_id, from_state_id, to_state_id, created_at) VALUES (:id, :action_name, :state_machine_id, :from_state_id, :to_state_id, :created_at)',
            [
                'id' => Uuid::randomBytes(),
                'action_name' => $action,
                'state_machine_id' => Uuid::fromHexToBytes($machineId),
                'from_state_id' => Uuid::fromHexToBytes($from),
                'to_state_id' => Uuid::fromHexToBytes($to),
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]
        );
    }

    private function insertTranslation(string $stateId, string $name, string $languageId, Connection $connection): void
    {
        

if ($this->client->indices()->exists(['index' => $index])) {
                continue;
            }

            $indices[$alias] = $index;

            $this->create($indexer, $index, $alias);

            $iterator = $indexer->getIterator();
            $indexTasks[] = [
                'id' => Uuid::randomBytes(),
                '`entity`' => $indexer->getEntity(),
                '`index`' => $index,
                '`alias`' => $alias,
                '`doc_count`' => $iterator->fetchCount(),
            ];
        }

        $this->connection->executeStatement(
            'DELETE FROM admin_elasticsearch_index_task WHERE `entity` IN (:entities)',
            ['entities' => $entities],
            ['entities' => ArrayParameterType::STRING]
        );

ToManyAssociationDefinition::class,
            ],
            $this->createMock(ValidatorInterface::class),
            $this->createMock(EntityWriteGatewayInterface::class)
        );
    }

    public function testFkExtensionFieldHydration(): void
    {
        $definition = $this->definitionInstanceRegistry->get(FkExtensionFieldTest::class);

        $id = Uuid::randomBytes();
        $normal = Uuid::randomBytes();
        $extended = Uuid::randomBytes();

        $rows = [
            [
                'test.id' => $id,
                'test.name' => 'test',
                'test.normalFk' => $normal,
                'test.extendedFk' => $extended,
            ],
        ];

        

$localeId = $this->connection->executeQuery(
            'SELECT id FROM `locale` WHERE `code` = :code',
            [
                'code' => 'vi-VN',
            ]
        )->fetchFirstColumn();

        if ($langId) {
            return $langId[0];
        }

        $newLanguageId = Uuid::randomBytes();
        $statement = $this->connection->prepare('INSERT INTO `language` (`id`, `name`, `locale_id`, `translation_code_id`, `created_at`) VALUES (?, ?, ?, ?, ?)');
        $statement->executeStatement([$newLanguageId, 'Vietnamese', $localeId[0], $localeId[0], '2021-04-01 04:41:12.045']);

        return $newLanguageId;
    }

    private function createSearchConfigFieldForNewLanguage(string $newLanguageId): void
    {
        $configId = $this->connection->executeQuery(
            'SELECT id FROM `product_search_config` WHERE `language_id` = :languageId',
            [

    private function addDefaultContactFormLayout(Connection $connection, string $formType, string $formTypeDe): void
    {
        $slotTranslations = [];
        $languageEn = Uuid::fromHexToBytes(Defaults::LANGUAGE_SYSTEM);
        $languageDe = $this->getLanguageDeId($connection);
        $versionId = Uuid::fromHexToBytes(Defaults::LIVE_VERSION);

        // cms page         $page = [
            'id' => Uuid::randomBytes(),
            'type' => 'page',
            'locked' => 1,
            'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
        ];
        $pageEng = [
            'cms_page_id' => $page['id'],
            'language_id' => $languageEn,
            'name' => 'Default shop page layout with ' . $formType . ' form',
            'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
        ];
        $pageDeu = [
            

private function insertTransition(string $action, string $machineId, ?string $from, ?string $to, Connection $connection): void
    {
        if ($from === null || $to === null) {
            return;
        }

        $connection->executeStatement(
            'REPLACE INTO state_machine_transition (id, action_name, state_machine_id, from_state_id, to_state_id, created_at) VALUES (:id, :action_name, :state_machine_id, :from_state_id, :to_state_id, :created_at)',
            [
                'id' => Uuid::randomBytes(),
                'action_name' => $action,
                'state_machine_id' => Uuid::fromHexToBytes($machineId),
                'from_state_id' => Uuid::fromHexToBytes($from),
                'to_state_id' => Uuid::fromHexToBytes($to),
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]
        );
    }

    private function insertTranslations(string $stateId, Connection $connection): void
    {
        

                'product_stream_id' => Uuid::fromHexToBytes($id),
                'language_id' => Uuid::fromHexToBytes(Defaults::LANGUAGE_SYSTEM),
                'name' => 'Stream',
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]
        );

        $this->connection->insert(
            'product_stream_filter',
            [
                'id' => Uuid::randomBytes(),
                'type' => 'equals',
                'field' => 'manufacturerId',
                'value' => $manufacturerId,
                'position' => 1,
                'product_stream_id' => Uuid::fromHexToBytes($id),
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]
        );

        $this->connection->insert(
            'product_stream_filter',
            [

            ['actionName' => SendMailAction::getName()]
        );

        $createdAt = (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT);
        $eventActionIds = [];
        foreach ($eventActions as $flowValue) {
            $flowSequences = [];
            $flowId = Uuid::randomBytes();
            $saleSChannelFlowSequenceId = null;
            if ($flowValue['sales_channel_ids'] !== null) {
                // get rule_id from sales_channel_rule if rule of $salesChannelIds already exists                 $ruleId = $this->getRuleBySalesChannelIds($connection, $flowValue['sales_channel_ids'], $createdAt);

                $saleSChannelFlowSequenceId = Uuid::randomBytes();
                // an if condition will be added for the new flow if event_action has specific sales channels                 $flowSequences[] = $this->buildSequenceData(
                    $saleSChannelFlowSequenceId,
                    $flowId,
                    $ruleId,
                    

use Shopware\Tests\Integration\Core\Checkout\Cart\Promotion\Helpers\Fakes\FakeQueryBuilder;

/** * @internal * * @covers \Shopware\Core\Installer\Configuration\AdminConfigurationService */
class AdminConfigurationServiceTest extends TestCase
{
    public function testCreateAdmin(): void
    {
        $localeId = Uuid::randomBytes();
        $connection = $this->createMock(Connection::class);
        $connection->expects(static::once())
            ->method('insert')
            ->with(
                'user',
                static::callback(static function Darray $data) use ($localeId): bool {
                    static::assertEquals('admin', $data['username']);
                    static::assertEquals('first', $data['first_name']);
                    static::assertEquals('last', $data['last_name']);
                    static::assertEquals('test@test.com', $data['email']);
                    static::assertEquals($localeId, $data['locale_id']);
                    

class UuidTest extends TestCase
{
    public function testRandomHex(): void
    {
        static::assertNotEquals(Uuid::randomHex(), Uuid::randomHex());
        static::assertTrue(Uuid::isValid(Uuid::randomHex()));
        static::assertStringNotContainsString('-', Uuid::randomHex());
    }

    public function testRandomBytes(): void
    {
        static::assertNotEquals(Uuid::randomBytes(), Uuid::randomBytes());
        static::assertSame(16, mb_strlen(Uuid::randomBytes(), '8bit'));
    }

    public function testHexRoundtrip(): void
    {
        $hex = Uuid::randomHex();
        $bytes = Uuid::fromHexToBytes($hex);

        static::assertSame($hex, Uuid::fromBytesToHex($bytes));
    }

    

#[Package('core')] class Migration1610625925RequireDataProtectionCheckbox extends MigrationStep
{
    public function getCreationTimestamp(): int
    {
        return 1610625925;
    }

    public function update(Connection $connection): void
    {
        $connection->insert('system_config', [
            'id' => Uuid::randomBytes(),
            'configuration_key' => 'core.loginRegistration.requireDataProtectionCheckbox',
            'configuration_value' => json_encode(['_value' => false]),
            'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
        ]);
    }

    public function updateDestructive(Connection $connection): void
    {
        // implement update destructive     }
}

        $this->importTranslation('product_sorting_translation', $translations, $connection);
    }

    /** * @return array{id: string, priority: int, active: int, locked: int, fields: string, created_at: string, translations: array{de-DE: string, en-GB: string}} */
    private function getTopsellerSorting(): array
    {
        return [
            'id' => Uuid::randomBytes(),
            'url_key' => 'topseller',
            'priority' => 0,
            'active' => 1,
            'locked' => 0,
            'fields' => json_encode([['field' => 'product.sales', 'order' => 'desc', 'priority' => 1, 'naturalSorting' => 0]], \JSON_THROW_ON_ERROR),
            'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            'translations' => [
                'de-DE' => 'Topseller',
                'en-GB' => 'Topseller',
            ],
        ];
    }

$index = $alias . '_' . $timestamp->getTimestamp();

            $hasAlias = $this->indexCreator->aliasExists($alias);

            $this->indexCreator->createIndex($definition, $index, $alias, $context);

            $iterator = $this->iteratorFactory->createIterator($definition->getEntityDefinition());

            // We don't need an index task, when it's the first indexing. This will allow alias swapping to nothing             if ($hasAlias) {
                $this->connection->insert('elasticsearch_index_task', [
                    'id' => Uuid::randomBytes(),
                    '`entity`' => $definition->getEntityDefinition()->getEntityName(),
                    '`index`' => $index,
                    '`alias`' => $alias,
                    '`doc_count`' => $iterator->fetchCount(),
                ]);
            }
        }
    }

    private function handleIndexingMessage(ElasticsearchIndexingMessage $message): void
    {
        

'Entity exists but should not.'
        );
    }

    /** * @param string[] $scopes * @param string[]|null $aclPermissions */
    public function authorizeBrowser(TestBrowser $browser, array $scopes = [], ?array $aclPermissions = null): void
    {
        $username = Uuid::randomHex();
        $userId = Uuid::randomBytes();

        $connection = $browser->getContainer()->get(Connection::class);

        $user = [
            'id' => $userId,
            'first_name' => $username,
            'last_name' => '',
            'username' => $username,
            'password' => TestDefaults::HASHED_PASSWORD,
            'locale_id' => $this->getLocaleOfSystemLanguage($connection),
            'active' => 1,
            

    public function getCreationTimestamp(): int
    {
        return 1599112309;
    }

    public function update(Connection $connection): void
    {
        $value = $this->isInstallation() ? 'true' : 'false';

        $connection->insert('system_config', [
            'id' => Uuid::randomBytes(),
            'configuration_key' => 'core.listing.disableEmptyFilterOptions',
            'configuration_value' => '{"_value": ' . $value . '}',
            'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
        ]);
    }

    public function updateDestructive(Connection $connection): void
    {
        // implement update destructive     }
}