function OptimizedPhpArrayDumperTest::getDefinitionsDataProvider

Data provider for testGetServiceDefinitions().

Return value

array[] Returns data-set elements with:

• parameters as returned by ContainerBuilder.
• parameters as expected in the container definition.
• frozen value

File

core/tests/Drupal/Tests/Component/DependencyInjection/Dumper/OptimizedPhpArrayDumperTest.php, line 238

Class

OptimizedPhpArrayDumperTest

@coversDefaultClass <a href="/api/drupal/core%21lib%21Drupal%21Component%21DependencyInjection%21Dumper%21OptimizedPhpArrayDumper.php/class/OptimizedPhpArrayDumper/11.x" title="OptimizedPhpArrayDumper dumps a service container as a serialized PHP array." class="local">\Drupal\Component\DependencyInjection\Dumper\OptimizedPhpArrayDumper</a> @group DependencyInjection

Namespace

Code

public static function getDefinitionsDataProvider() {
    $base_service_definition = [
        'class' => '\\stdClass',
        'public' => TRUE,
        'file' => FALSE,
        'synthetic' => FALSE,
        'lazy' => FALSE,
        'arguments' => [],
        'arguments_count' => 0,
        'properties' => [],
        'calls' => [],
        'shared' => TRUE,
        'factory' => FALSE,
        'configurator' => FALSE,
    ];
    // Test basic flags.
    $service_definitions[] = [] + $base_service_definition;
    $service_definitions[] = [
        'public' => FALSE,
    ] + $base_service_definition;
    $service_definitions[] = [
        'file' => 'test_include.php',
    ] + $base_service_definition;
    $service_definitions[] = [
        'synthetic' => TRUE,
    ] + $base_service_definition;
    $service_definitions[] = [
        'shared' => FALSE,
    ] + $base_service_definition;
    $service_definitions[] = [
        'lazy' => TRUE,
    ] + $base_service_definition;
    // Test a basic public Reference.
    $service_definitions[] = [
        'arguments' => [
            'foo',
            new Reference('bar'),
        ],
        'arguments_count' => 2,
        'arguments_expected' => static::getCollection([
            'foo',
            static::getServiceCall('bar'),
        ]),
    ] + $base_service_definition;
    // Test a public reference that should not throw an Exception.
    $reference = new Reference('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE);
    $service_definitions[] = [
        'arguments' => [
            $reference,
        ],
        'arguments_count' => 1,
        'arguments_expected' => static::getCollection([
            static::getServiceCall('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE),
        ]),
    ] + $base_service_definition;
    // Test a private shared service, denoted by having a Reference.
    $private_definition = [
        'class' => '\\stdClass',
        'public' => FALSE,
        'arguments_count' => 0,
    ];
    $service_definitions[] = [
        'arguments' => [
            'foo',
            new Reference('private_definition'),
        ],
        'arguments_count' => 2,
        'arguments_expected' => static::getCollection([
            'foo',
            static::getPrivateServiceCall('private_definition', $private_definition, TRUE),
        ]),
    ] + $base_service_definition;
    // Test a service closure.
    $service_definitions[] = [
        'arguments' => [
            'foo',
            [
                'alias-1' => new ServiceClosureArgument(new Reference('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE)),
                'alias-2' => new ServiceClosureArgument(new Reference('bar', ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE)),
            ],
        ],
        'arguments_count' => 2,
        'arguments_expected' => static::getCollection([
            'foo',
            static::getCollection([
                'alias-1' => static::getServiceClosureCall('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE),
                'alias-2' => static::getServiceClosureCall('bar', ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE),
            ]),
        ]),
    ] + $base_service_definition;
    // Test a private non-shared service, denoted by having a Definition.
    $private_definition_object = new Definition('\\stdClass');
    $private_definition_object->setPublic(FALSE);
    $service_definitions[] = [
        'arguments' => [
            'foo',
            $private_definition_object,
        ],
        'arguments_count' => 2,
        'arguments_expected' => static::getCollection([
            'foo',
            static::getPrivateServiceCall(NULL, $private_definition),
        ]),
    ] + $base_service_definition;
    // Test a deep collection without a reference.
    $service_definitions[] = [
        'arguments' => [
            [
                [
                    'foo',
                ],
            ],
        ],
        'arguments_count' => 1,
    ] + $base_service_definition;
    // Test a deep collection with a reference to resolve.
    $service_definitions[] = [
        'arguments' => [
            [
                new Reference('bar'),
            ],
        ],
        'arguments_count' => 1,
        'arguments_expected' => static::getCollection([
            static::getCollection([
                static::getServiceCall('bar'),
            ]),
        ]),
    ] + $base_service_definition;
    // Test an IteratorArgument collection with a reference to resolve.
    $service_definitions[] = [
        'arguments' => [
            new IteratorArgument([
                new Reference('bar'),
            ]),
        ],
        'arguments_count' => 1,
        'arguments_expected' => static::getCollection([
            static::getIterator([
                static::getServiceCall('bar'),
            ]),
        ]),
    ] + $base_service_definition;
    // Test a collection with a variable to resolve.
    $service_definitions[] = [
        'arguments' => [
            new Parameter('llama_parameter'),
        ],
        'arguments_count' => 1,
        'arguments_expected' => static::getCollection([
            static::getParameterCall('llama_parameter'),
        ]),
    ] + $base_service_definition;
    // Test getMethodCalls.
    $calls = [
        [
            'method',
            static::getCollection([]),
        ],
        [
            'method2',
            static::getCollection([]),
        ],
    ];
    $service_definitions[] = [
        'calls' => $calls,
    ] + $base_service_definition;
    $service_definitions[] = [
        'shared' => FALSE,
    ] + $base_service_definition;
    // Test factory.
    $service_definitions[] = [
        'factory' => [
            new Reference('bar'),
            'factoryMethod',
        ],
        'factory_expected' => [
            static::getServiceCall('bar'),
            'factoryMethod',
        ],
    ] + $base_service_definition;
    // Test invalid factory - needed to test deep dumpValue().
    $service_definitions[] = [
        'factory' => [
            [
                'foo',
                'llama',
            ],
            'factoryMethod',
        ],
    ] + $base_service_definition;
    // Test properties.
    $service_definitions[] = [
        'properties' => [
            '_value' => 'llama',
        ],
    ] + $base_service_definition;
    // Test configurator.
    $service_definitions[] = [
        'configurator' => [
            new Reference('bar'),
            'configureService',
        ],
        'configurator_expected' => [
            static::getServiceCall('bar'),
            'configureService',
        ],
    ] + $base_service_definition;
    $services_provided = [];
    $services_provided[] = [
        [],
        [],
    ];
    foreach ($service_definitions as $service_definition) {
        $definition = (new Prophet())->prophesize('\\Symfony\\Component\\DependencyInjection\\Definition');
        $definition->getClass()
            ->willReturn($service_definition['class']);
        $definition->isPublic()
            ->willReturn($service_definition['public']);
        $definition->getFile()
            ->willReturn($service_definition['file']);
        $definition->isSynthetic()
            ->willReturn($service_definition['synthetic']);
        $definition->isLazy()
            ->willReturn($service_definition['lazy']);
        $definition->getArguments()
            ->willReturn($service_definition['arguments']);
        $definition->getProperties()
            ->willReturn($service_definition['properties']);
        $definition->getMethodCalls()
            ->willReturn($service_definition['calls']);
        $definition->isShared()
            ->willReturn($service_definition['shared']);
        $definition->getDecoratedService()
            ->willReturn(NULL);
        $definition->getFactory()
            ->willReturn($service_definition['factory']);
        $definition->getConfigurator()
            ->willReturn($service_definition['configurator']);
        // Preserve order.
        $filtered_service_definition = [];
        foreach ($base_service_definition as $key => $value) {
            $filtered_service_definition[$key] = $service_definition[$key];
            unset($service_definition[$key]);
            if ($key == 'class' || $key == 'arguments_count') {
                continue;
            }
            if ($filtered_service_definition[$key] === $base_service_definition[$key]) {
                unset($filtered_service_definition[$key]);
            }
        }
        // Add remaining properties.
        $filtered_service_definition += $service_definition;
        // Allow to set _expected values.
        foreach ([
            'arguments',
            'factory',
            'configurator',
        ] as $key) {
            $expected = $key . '_expected';
            if (isset($filtered_service_definition[$expected])) {
                $filtered_service_definition[$key] = $filtered_service_definition[$expected];
                unset($filtered_service_definition[$expected]);
            }
        }
        if (isset($filtered_service_definition['public']) && $filtered_service_definition['public'] === FALSE) {
            $services_provided[] = [
                [
                    'foo_service' => $definition->reveal(),
                ],
                [],
            ];
            continue;
        }
        $services_provided[] = [
            [
                'foo_service' => $definition->reveal(),
            ],
            [
                'foo_service' => static::serializeDefinition($filtered_service_definition),
            ],
        ];
    }
    return $services_provided;
}