assertNotFalse example

'product:write', 'product:read'], ['api.test.route'], false,
            ],
            [
                ['app.all'], ['app'], true,
            ],
        ];
    }

    private function registerActionButton(string $appName, string $actionId): void
    {
        $iconRaw = \file_get_contents(__DIR__ . '/../../../../../../tests/integration/Core/Framework/App/Manifest/_fixtures/test/icon.png');
        static::assertNotFalse($iconRaw);

        $this->appRepository->create([[
            'name' => $appName,
            'active' => true,
            'path' => __DIR__ . '/../../App/Manifest/_fixtures/test',
            'iconRaw' => $iconRaw,
            'version' => '0.0.1',
            'label' => 'test',
            'accessToken' => 'test',
            'actionButtons' => [
                [
                    

  public function testNormal() {
    $contents = $this->randomMachineName(10);
    $source = $this->createFile(NULL, $contents);
    $desired_filepath = 'public://' . $this->randomMachineName();

    // Clone the object so we don't have to worry about the function changing     // our reference copy.     $result = $this->fileRepository->move(clone $source, $desired_filepath, FileSystemInterface::EXISTS_ERROR);

    // Check the return status and that the contents changed.     $this->assertNotFalse($result, 'File moved successfully.');
    $this->assertFileDoesNotExist($source->getFileUri());
    $this->assertEquals($contents, file_get_contents($result->getFileUri()), 'Contents of file correctly written.');

    // Check that the correct hooks were called.     $this->assertFileHooksCalled(['move', 'load', 'update']);

    // Make sure we got the same file back.     $this->assertEquals($source->id(), $result->id(), new FormattableMarkup("Source file id's' %fid is unchanged after move.", ['%fid' => $source->id()]));

    // Reload the file from the database and check that the changes were     // actually saved.

$order->getCurrency()->getIsoCode(),
                        Context::createDefaultContext()->getLanguageId(),
                        Context::createDefaultContext(),
                    ),
                    $rendered->getHtml()
                );

                static::assertNotNull($locale = $order->getLanguage()->getLocale());
                $formatter = new \IntlDateFormatter($locale->getCode(), \IntlDateFormatter::MEDIUM, \IntlDateFormatter::NONE);
                $formattedDate = $formatter->format(new \DateTime());

                static::assertNotFalse($formattedDate);
                static::assertStringContainsString(
                    sprintf('Date %s', $formattedDate),
                    $rendered->getHtml()
                );
            },
        ];

        yield 'render with different language' => [
            [7],
            function DDocumentGenerateOperation $operation, ContainerInterface $container) use ($documentDate): void {
                $container->get('order.repository')->upsert([[
                    

$this->pluginCollection = $this->createMock(KernelPluginCollection::class);
        $this->twig = $this->createMock(Environment::class);
        $this->controller = new CustomSnippetFormatController($this->pluginCollection, $this->twig);
    }

    public function testGetSnippetsWithoutPlugins(): void
    {
        $response = $this->controller->snippets();

        static::assertInstanceOf(JsonResponse::class, $response);
        $content = $response->getContent();
        static::assertNotFalse($content);
        $content = \json_decode($content, true, 512, \JSON_THROW_ON_ERROR);

        static::assertArrayHasKey('data', $content);
        static::assertSame([
            'address/city',
            'address/company',
            'address/country',
            'address/country_state',
            'address/department',
            'address/first_name',
            'address/last_name',
            

$thumbnailSize = $this->getPublicFilesystem()->fileSize($thumbnailPath);
        static::assertLessThanOrEqual($originalSize, $thumbnailSize);
    }

    public function testItUsesFolderConfigGenerateThumbnails(): void
    {
        $this->setFixtureContext($this->context);
        $media = $this->getJpgWithFolderWithoutThumbnails();

        $filePath = $this->urlGenerator->getRelativeMediaUrl($media);
        $resource = fopen(__DIR__ . '/../fixtures/shopware.jpg', 'rb');
        static::assertNotFalse($resource);

        $this->getPublicFilesystem()->writeStream($filePath, $resource);

        $this->thumbnailService->updateThumbnails($media, $this->context, false);

        /** @var MediaEntity $updatedMedia */
        $updatedMedia = $this->mediaRepository->search(new Criteria([$media->getId()]), $this->context)->get($media->getId());

        $thumbnails = $updatedMedia->getThumbnails();
        static::assertInstanceOf(MediaThumbnailCollection::class, $thumbnails);
        static::assertEquals(0, $thumbnails->count());
    }

class CustomSnippetFormatControllerTest extends TestCase
{
    use AdminFunctionalTestBehaviour;

    public function testGetSnippetsWithoutPlugins(): void
    {
        $url = '/api/_action/custom-snippet';
        $client = $this->getBrowser();
        $client->request('GET', $url);

        $content = $client->getResponse()->getContent();
        static::assertNotFalse($content);
        static::assertJson($content);
        $content = json_decode($content, true, 512, \JSON_THROW_ON_ERROR);

        static::assertArrayHasKey('data', $content);

        static::assertSame([
            'address/city',
            'address/company',
            'address/country',
            'address/country_state',
            'address/department',
            

            ],
            'cartPriceTaxes' => [
                [
                    'tax' => 26,
                    'taxRate' => 13,
                    'price' => 200,
                ],
            ],
        ], \JSON_THROW_ON_ERROR);

        static::assertNotFalse($responseContent);
        $response = new Response(200, [], $responseContent);

        $client = static::createMock(Client::class);
        $client
            ->expects(static::once())
            ->method('post')
            ->with($url, static::isType('array'))
            ->willReturn($response);

        $taxProviderPayloadService = new TaxProviderPayloadService(
            $appPayloadServiceHelper,
            

'SELECT `language`.id FROM `language` INNER JOIN `locale` ON `language`.`locale_id` = `locale`.`id` WHERE `code` = :code LIMIT 1',
            ['code' => 'en-GB']
        );

        $documentTypeName = $connection->fetchOne(
            'SELECT `name` FROM `document_type_translation` WHERE `document_type_id` = :documentTypeId AND `language_id` = :languageId',
            [
                'documentTypeId' => $cancellationId,
                'languageId' => $enLangId,
            ]
        );
        static::assertNotFalse($documentTypeName);

        $documentBaseConfig = $connection->fetchAssociative(
            'SELECT `name`, `filename_prefix` FROM `document_base_config` WHERE `document_type_id` = :documentTypeId',
            [
                'documentTypeId' => $cancellationId,
            ]
        );
        static::assertNotFalse($documentBaseConfig);

        static::assertEquals('Cancellation invoice', $documentTypeName);
        static::assertEquals('cancellation_invoice', $documentBaseConfig['name']);
        

    public function testIterate(): void
    {
        $c = $this->getContainer()->get(Connection::class);
        static::assertEmpty($c->fetchAllAssociative('SELECT `index` FROM `admin_elasticsearch_index_task`'));

        $this->registry->iterate(new AdminIndexingBehavior(true));

        $index = $c->fetchOne('SELECT `index` FROM `admin_elasticsearch_index_task`');

        static::assertNotFalse($index);

        static::assertTrue($this->client->indices()->exists(['index' => $index]));

        $indices = array_values($this->client->indices()->getMapping(['index' => $index]))[0];
        $properties = $indices['mappings']['properties'];

        $expectedProperties = [
            'id' => ['type' => 'keyword'],
            'text' => ['type' => 'text'],
            'entityName' => ['type' => 'keyword'],
            'parameters' => ['type' => 'keyword'],
            

  public function testLongPassword($password, $allowed) {

    $passwordHash = $this->passwordHasher->hash($password);

    if ($allowed) {
      $this->assertNotFalse($passwordHash);
    }
    else {
      $this->assertFalse($passwordHash);
    }
  }

  /** * Provides the test matrix for testLongPassword(). */
  public function providerLongPasswords() {
    // '512 byte long password is allowed.'

  public function testLongPassword($password, $allowed) {
    // cspell:disable     $bogusHash = '$S$5TOxWPdvJRs0P/xZBdrrPlGgzViOS0drHu3jaIjitesfttrp18bk';
    // cspell:enable
    $passwordService = new PhpassHashedPassword(new PhpPassword());

    if ($allowed) {
      $hash = $passwordService->hash($password);
      $this->assertNotFalse($hash);
      $result = $passwordService->check($password, $hash);
      $this->assertTrue($result);
    }
    else {
      $result = $passwordService->check($password, $bogusHash);
      $this->assertFalse($result);
    }
  }

  /** * Provides the test matrix for testLongPassword(). */

$eventActions = $this->connection->fetchAllAssociative(
            'SELECT active FROM event_action WHERE action_name = :actionName',
            ['actionName' => SendMailAction::getName()]
        );

        static::assertSame(0, (int) $eventActions[0]['active']);
        static::assertCount(1, $eventActions);

        $ruleName = $this->connection->fetchOne('SELECT `name` FROM rule WHERE name LIKE "%Match%"');

        static::assertNotFalse($ruleName);
    }

    private function createEventActionWithSalesChannelAndRule(): void
    {
        $scName = $this->getRandomString(255);
        $data = [
            'id' => $this->ids->create('sc-id'),
            'name' => $scName,
            'typeId' => Defaults::SALES_CHANNEL_TYPE_STOREFRONT,
            'customerGroupId' => TestDefaults::FALLBACK_CUSTOMER_GROUP,
            'currencyId' => Defaults::CURRENCY,
            

$this->createTestData();
    }

    public function testOrderNotLoggedIn(): void
    {
        $this->browser
            ->request(
                'POST',
                '/store-api/checkout/order'
            );

        static::assertNotFalse($this->browser->getResponse()->getContent());

        $response = \json_decode($this->browser->getResponse()->getContent(), true, 512, \JSON_THROW_ON_ERROR);

        static::assertArrayHasKey('errors', $response);
        static::assertSame('CHECKOUT__CUSTOMER_NOT_LOGGED_IN', $response['errors'][0]['code']);
    }

    public function testOrderEmptyCart(): void
    {
        $this->createCustomerAndLogin();

        

$fileIcon = '';
        if (file_exists($iconPath)) {
            $fileIcon = \file_get_contents($iconPath);
        }

        $appFlowAction->setIconRaw($fileIcon !== false ? $fileIcon : null);

        $subscriber = new AppFlowActionLoadedSubscriber();
        $event = new EntityLoadedEvent(new AppFlowActionDefinition(), [$appFlowAction], Context::createDefaultContext());

        $subscriber->unserialize($event);
        static::assertNotFalse($fileIcon);

        static::assertEquals(
            base64_encode($fileIcon),
            $appFlowAction->getIcon()
        );
    }
}

public function testImportCreate() {
    $node_type_id = 'import';
    $node_type_config_name = "node.type.$node_type_id";

    // Simulate config data to import.     $active = $this->container->get('config.storage');
    $sync = $this->container->get('config.storage.sync');
    $this->copyConfig($active, $sync);
    // Manually add new node type.     $src_dir = __DIR__ . '/../../../modules/node_test_config/sync';
    $target_dir = Settings::get('config_sync_directory');
    $this->assertNotFalse(\Drupal::service('file_system')->copy("$src_dir/$node_type_config_name.yml", "$target_dir/$node_type_config_name.yml"));

    // Import the content of the sync directory.     $this->configImporter()->import();

    // Check that the content type was created.     $node_type = NodeType::load($node_type_id);
    $this->assertNotEmpty($node_type, 'Import node type from sync was created.');
    $this->assertNull(FieldConfig::loadByName('node', $node_type_id, 'body'));
  }

}