Symfony Dependency Injection Test Laravel Package

Getting Started

Minimal Steps

1. Installation

   composer require --dev matthiasnoback/symfony-dependency-injection-test
   

2. First Test Case Extend AbstractExtensionTestCase for container extensions or AbstractCompilerPassTestCase for compiler passes. Example:

   use Matthias\SymfonyDependencyInjectionTest\PhpUnit\AbstractExtensionTestCase;
   
   class MyExtensionTest extends AbstractExtensionTestCase
   {
       protected function getContainerExtensions(): array
       {
           return [new MyExtension()];
       }
   }
   

3. Run Tests

   phpunit
   

First Use Case

Test a simple container extension that loads services from configuration:

public function testLoadsServicesFromConfig()
{
    $this->loadFromConfiguration(
        ['service' => ['enabled' => true]]
    );

    $this->assertContainerBuilderHasService('my_service');
}

Implementation Patterns

Testing Container Extensions

1. Configuration Loading Use loadFromConfiguration() to simulate loading YAML/XML/PHP config:

   $this->loadFromConfiguration(['param' => 'value']);
   

2. Service Verification Assert services exist, are public, or have specific tags:

   $this->assertContainerBuilderHasService('service_name');
   $this->assertContainerBuilderHasPublicService('service_name');
   $this->assertContainerBuilderHasTaggedService('service_name', 'tag_name');
   

3. Parameter Validation Check if parameters are defined and match expected values:

   $this->assertContainerBuilderHasParameter('param_name');
   $this->assertContainerBuilderHasParameter('param_name', 'expected_value');
   

Testing Compiler Passes

1. Extension Setup Extend AbstractCompilerPassTestCase and define passes:

   protected function getCompilerPasses(): array
   {
       return [new MyCompilerPass()];
   }
   

2. Pass Execution Simulate pass execution with compile():

   $this->compile();
   

3. Post-Compilation Checks Verify services/parameters after compilation:

   $this->assertContainerBuilderHasService('modified_service');
   

Integration with Laravel

1. Laravel-Specific Setup Use Laravel’s Container facade to instantiate extensions/passes:

   $extension = app()->make(MyExtension::class);
   $this->loadFromConfiguration([...]);
   

2. Testing Service Providers Mock Laravel’s ServiceProvider boot/register methods:

   $this->assertContainerBuilderHasService('app\MyService');
   

3. Configuration Overrides Override Laravel’s config in tests:

   config(['my_package.enabled' => true]);
   $this->loadFromConfiguration(config('my_package'));
   

Gotchas and Tips

Pitfalls

1. Configuration Merging

   • Issue: loadFromConfiguration() merges with existing config. Clear the container first if needed:

     $this->resetContainer();
     $this->loadFromConfiguration([...]);
     

   • Tip: Use loadFromExtension() for extension-specific config isolation.

2. Service Name Conflicts

   • Issue: Laravel’s service names (e.g., App\Services\MyService) may conflict with test assertions.
   • Fix: Use fully qualified names or aliases:

     $this->assertContainerBuilderHasService('app.services.my_service');
     

3. Compiler Pass Order

   • Issue: Passes may depend on each other. Ensure correct order in getCompilerPasses().
   • Tip: Use setPriority() in passes for explicit ordering.

4. Laravel-Specific Quirks

   • Issue: Laravel’s ServiceProvider lifecycle (boot/register) isn’t directly testable.
   • Workaround: Test individual components (extensions/passes) separately and integrate via Laravel’s container.

Debugging

1. Dump Container State Use dumpContainerState() to inspect services/parameters:

   $this->dumpContainerState();
   

2. Assertion Failures

   • Tip: Use assertContainerBuilderHasServiceDefinitionThat() for granular checks:

     $this->assertContainerBuilderHasServiceDefinitionThat(
         'service_name',
         $this->isInstanceOf(MyService::class)
     );
     

3. Configuration Validation

   • Tip: Validate config schemas with assertConfigurationIsValid():

     $this->assertConfigurationIsValid([...]);
     

Extension Points

1. Custom Assertions Extend AbstractExtensionTestCase to add custom assertions:

   protected function assertCustomCondition()
   {
       $this->assertTrue($this->container->has('expected_service'));
   }
   

2. Mocking Dependencies Use PHPUnit’s mocking to isolate tests:

   $this->mockService('dependency', Mockery::mock(MyDependency::class));
   

3. Laravel-Specific Extensions Create a base test case for Laravel projects:

   abstract class LaravelExtensionTestCase extends AbstractExtensionTestCase
   {
       protected function getContainer()
       {
           return app()->make('service_container');
       }
   }
   

Performance Tips

1. Reset Container Between Tests Avoid state leakage:

   protected function tearDown(): void
   {
       $this->resetContainer();
       parent::tearDown();
   }
   

2. Focus on Critical Paths Prioritize testing:

   • Container extension configuration.
   • Compiler pass transformations.
   • Service binding/aliasing.