getVars example

$serializer = new Serializer($normalizers, [new JsonEncoder()]);

        $context = Context::createDefaultContext();

        $context->addExtension('foo', new ArrayEntity());

        $serialized = $serializer->serialize($context, 'json');
        $deserialized = $serializer->deserialize($serialized, Context::class, 'json');

        static::assertInstanceOf(Context::class, $deserialized);

        static::assertEmpty($deserialized->getVars()['extensions']);
    }
}

$struct = new ArrayStruct();
        static::assertSame('array_struct', $struct->getApiAlias());

        $otherStruct = new ArrayStruct([], 'anAlias');
        static::assertSame('anAlias', $otherStruct->getApiAlias());
    }

    public function testGetVars(): void
    {
        $dataSet = ['a' => 'a', 'b' => 'b'];
        $arrayStruct = new ArrayStruct($dataSet);
        static::assertSame($dataSet, $arrayStruct->getVars());
    }

    public function testGetIterator(): void
    {
        $arrayStruct = new ArrayStruct();
        static::assertInstanceOf(\ArrayIterator::class, $arrayStruct->getIterator());
    }

    public function testCount(): void
    {
        $arrayStruct = new ArrayStruct();
        

    /** * @param array<string, list<Entity>> $mapping * * @return array<string, list<Entity>> */
    private function map(Entity $entity, array $mapping): array
    {
        $mapping[$entity->getInternalEntityName()][] = $entity;

        $vars = $entity->getVars();
        foreach ($vars as $value) {
            if ($value instanceof Entity) {
                $mapping = $this->map($value, $mapping);

                continue;
            }

            if ($value instanceof Collection) {
                $value = $value->getElements();
            }
            if (!\is_array($value)) {
                

$product = $this->productRepository->search($criteria, Context::createDefaultContext())->getEntities()->get($productId);
        static::assertNotNull($product);

        // Self Reference without autoload should be loaded         static::assertTrue($product->hasExtension('ManyToOneSelfReference'));
        // Self Reference with autoload should NOT be loaded         static::assertFalse($product->hasExtension('ManyToOneSelfReferenceAutoload'));

        $productExtension = $product->getExtension('ManyToOneSelfReference');
        static::assertInstanceOf(ProductEntity::class, $productExtension);
        static::assertSame($linkedProductId, $productExtension->getVars()['id']);
    }

    public function testVariantDoesNotInheritOneToOneAssociationFromParent(): void
    {
        $date = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', '2021-11-03 13:37:00');
        static::assertInstanceOf(\DateTimeImmutable::class, $date);
        $myDate = $date->format(Defaults::STORAGE_DATE_TIME_FORMAT);

        $context = Context::createDefaultContext();

        $this->productRepository->create([
            [

    public function getTranslated(): array
    {
        return $this->data['translated'] ?? [];
    }

    /** * @return array<string, mixed> */
    public function getVars(): array
    {
        $vars = parent::getVars();

        unset($vars['data']);

        return array_merge($vars, $this->data);
    }

    /** * @return array<string, mixed> */
    public function jsonSerialize(): array
    {
        

/** * @internal * * @covers \Shopware\Core\Framework\Update\Struct\ValidationResult */
class ValidationResultTest extends TestCase
{
    public function testCreateResult(): void
    {
        $result = new ValidationResult('name', true, 'message', ['var' => 'value']);
        $vars = $result->getVars();

        static::assertSame('name', $vars['name']);
        static::assertTrue($vars['result']);
        static::assertSame('message', $vars['message']);
        static::assertSame(['var' => 'value'], $vars['vars']);

        static::assertSame('update_api_validation_result', $result->getApiAlias());
    }
}

try {
                switch (true) {
                    case \is_array($value):
                        $value = \array_key_exists($part, $value) ? $value[$part] : null;

                        break;
                    case $value instanceof Entity:
                        $value = $value->get($part);

                        break;
                    case $value instanceof Struct:
                        $value = $value->getVars();
                        $value = \array_key_exists($part, $value) ? $value[$part] : null;

                        break;
                    default:
                        $value = null;
                }

                // if we are at the destination entity and it does not have a value for the field                 // on it's on, then try to get the translation fallback                 if ($value === null) {
                    $value = $entity->getTranslation($part);
                }

$context = $this->createSalesChannelContextWithNavigation();
        $seoUrlHandler = $this->getContainer()->get(SeoUrlPlaceholderHandlerInterface::class);

        /** @var NavigationPageLoadedEvent $event */
        $event = null;
        $this->catchEvent(NavigationPageLoadedEvent::class, $event);

        $page = $this->getPageLoader()->load($request, $context);

        static::assertInstanceOf(NavigationPage::class, $page);

        $meta = $page->getMetaInformation()->getVars();
        $canonical = $meta['canonical'];

        $seoUrl = $seoUrlHandler->replace($canonical, $request->getHost(), $context);

        static::assertEquals('/', $seoUrl);
    }

    /** * @return NavigationPageLoader */
    protected function getPageLoader()
    {

if (!$this->isAllowed($alias, (string) $property, $fields) && !$fields->hasNested($alias, (string) $property)) {
                unset($data[$property]);

                continue;
            }

            if (!\is_array($value)) {
                continue;
            }

            $object = $value;
            if (\array_key_exists($property, $struct->getVars())) {
                $object = $struct->getVars()[$property];
            }

            if ($object instanceof Struct) {
                $data[$property] = $this->loop($object, $fields, $value);

                continue;
            }

            // simple array of structs case             if ($this->isStructArray($object)) {
                

    private function findStruct(SeoResolverData $data, Struct $struct): void
    {
        if ($struct instanceof Entity) {
            $definition = $this->definitionInstanceRegistry->getByEntityClass($struct) ?? $this->salesChannelDefinitionInstanceRegistry->getByEntityClass($struct);
            if ($definition && $definition->isSeoAware()) {
                $data->add($definition->getEntityName(), $struct);
            }
        }

        foreach ($struct->getVars() as $item) {
            if ($item instanceof Collection) {
                foreach ($item as $collectionItem) {
                    if ($collectionItem instanceof Struct) {
                        $this->findStruct($data, $collectionItem);
                    }
                }
            } elseif ($item instanceof Struct) {
                $this->findStruct($data, $item);
            }
        }
    }

    

if (\array_key_exists($key, $data)) {
                continue;
            }
            $data[$key] = $value;
        }

        return $data;
    }

    public function getVars(): array
    {
        $data = parent::getVars();

        return $this->filterInvisibleFields($data);
    }

    public function getApiAlias(): string
    {
        if ($this->_entityName !== null) {
            return $this->_entityName;
        }

        $class = static::class;
        

            if (\array_key_exists('cms-aware', $enrichedCustomEntity->getFlags())) {
                static::assertCount(15, $enrichedCustomEntity->getFields());
            } else {
                static::assertCount(4, $enrichedCustomEntity->getFields());
            }

            static::assertNotNull($enrichedCustomEntity->getFlags()['admin-ui']);

            /** @var AdminUiEntity $adminUi */
            $adminUi = $enrichedCustomEntity->getFlags()['admin-ui'];
            static::assertEquals('sw-content', $adminUi->getVars()['navigationParent']);
            static::assertEquals(50, $adminUi->getVars()['position']);
            static::assertEquals('regular-tools-alt', $adminUi->getVars()['icon']);
            static::assertEquals('#f00', $adminUi->getVars()['color']);

            $listingColumns = $adminUi->getListing()->getColumns()->getContent();
            static::assertCount(3, $listingColumns);

            $listingColumnNames = array_map(static fn ($column) => $column->getVars()['ref'], $listingColumns);

            static::assertIsArray($listingColumns);

            

 catch (\Exception) {
            $viewData->setSuccess(false);
            $viewData->setMessages([
                'type' => self::DANGER,
                'text' => $this->trans('error.message-default'),
            ]);
        }

        if ($request->get('redirectTo') || $request->get('forwardTo')) {
            return $this->createActionResponse($request);
        }
        $params = array_merge($params, $viewData->getVars());

        $response = $this->renderStorefront(
            '@Storefront/storefront/component/address/address-editor-modal.html.twig',
            $params
        );

        $response->headers->set('x-robots-tag', 'noindex');

        return $response;
    }

    

/** * @dataProvider validEnvProvider * * @param array<string, string|bool> $env */
    public function testFromEnv(array $env, DatabaseConnectionInformation $expected): void
    {
        $this->setEnvVars($env);

        $info = DatabaseConnectionInformation::fromEnv();

        static::assertSame($expected->getVars(), $info->getVars());
    }

    public static function validEnvProvider(): \Generator
    {
        yield 'only database' => [
            [
                'DATABASE_URL' => 'mysql://root:root@localhost:3306/shopware',
            ],
            (new DatabaseConnectionInformation())->assign([
                'hostname' => 'localhost',
                'port' => 3306,
                

foreach ($decoded as $property => $value) {
            if (!$this->propertyAllowed($includes, $alias, $property)) {
                unset($decoded[$property]);

                continue;
            }

            if (!\is_array($value)) {
                continue;
            }

            $object = $struct->getVars()[$property];

            if ($object instanceof Collection) {
                /** @var list<Struct> $objects */
                $objects = array_values($object->getElements());

                foreach ($value as $index => $loop) {
                    $decoded[$property][$index] = $this->filterIncludes($includes, $loop, $objects[$index]);
                }

                continue;
            }