Testing Laravel Package

Getting Started

Minimal Setup

1. Installation Add the package via Composer:

   composer require symfony-cmf/testing
   

   Ensure your project uses Symfony CMF (e.g., symfony-cmf/core-bundle).

2. First Use Case Extend the provided base test classes for CMF-specific testing. Example:

   use Symfony\CMF\Testing\WebTestCase;
   
   class MyRouteTest extends WebTestCase
   {
       public function testRouteGeneration()
       {
           $this->assertRouteExists('/some-route');
       }
   }
   

   • Inherit from WebTestCase for HTTP/functional tests.
   • Use assertRouteExists() to validate CMF route generation.

3. Where to Look First

   • Base Classes: src/Resources/Test/ in the package for abstract test classes.
   • Documentation: Check README.md for bundle-specific helpers (e.g., RouteTestTrait, ContentTestTrait).
   • Examples: Browse tests/ in the package for real-world usage patterns.

Implementation Patterns

Common Workflows

1. Functional Testing with CMF Routes

   use Symfony\CMF\Testing\RouteTestTrait;
   
   class MyControllerTest extends WebTestCase
   {
       use RouteTestTrait;
   
       public function testDynamicRoute()
       {
           $this->assertRouteMatches(
               '/blog/{slug}',
               ['slug' => 'test-post'],
               ['_controller' => 'App\Controller\BlogController::show']
           );
       }
   }
   

   • Pattern: Use RouteTestTrait to validate route parameters, controllers, and requirements.

2. Content Repository Testing

   use Symfony\CMF\Testing\ContentTestTrait;
   use Doctrine\Common\DataFixtures\Purger\ORMPurger;
   
   class ContentFixtureTest extends WebTestCase
   {
       use ContentTestTrait;
   
       protected function setUp(): void
       {
           $this->loadFixtures([MyContentFixture::class]);
           $this->purgeDatabase(); // Uses ORMPurger by default
       }
   
       public function testContentPersistence()
       {
           $content = $this->getContent('blog_post');
           $this->assertEquals('Hello World', $content->getTitle());
       }
   }
   

   • Pattern: Leverage ContentTestTrait for fixture loading, repository queries, and assertions.
   • Tip: Override purgeDatabase() to customize the purger (e.g., for MongoDB).

3. Integration with Symfony’s Test Client

   public function testContentRouting()
   {
       $client = static::createClient();
       $crawler = $client->request('GET', '/blog/test-post');
   
       $this->assertEquals(200, $client->getResponse()->getStatusCode());
       $this->assertSelectorTextContains('h1', 'Test Post');
   }
   

   • Pattern: Combine createClient() with CMF-specific assertions (e.g., assertSelectorTextContains for Doctrine PHPCR-ODM or Doctrine ORM).

4. Testing Route Providers

   use Symfony\CMF\Testing\RouteProviderTestTrait;
   
   class CustomRouteProviderTest extends WebTestCase
   {
       use RouteProviderTestTrait;
   
       public function testProviderRoutes()
       {
           $this->assertRouteProviderGenerates(
               'app.route_provider',
               ['_route' => 'blog_show', 'slug' => 'test']
           );
       }
   }
   

   • Pattern: Use RouteProviderTestTrait to test dynamic route generation from providers.

Integration Tips

• Database Fixtures: Use loadFixtures() to pre-populate CMF content (e.g., BlogPost, Page entities).
• Kernel Bootstrapping: Extend WebTestCase to modify kernel configuration for tests:

  protected static function getKernelClass()
  {
      return TestKernel::class; // Custom kernel with test config
  }
  

• Mocking Services: Override container services in tests:

  protected function getKernelParameters()
  {
      return array_merge(parent::getKernelParameters(), [
          'kernel.test' => true,
          'cmf.test_mode' => true,
      ]);
  }
  

• PHPCR-ODM: For PHPCR-based CMF projects, use PHPCRTestTrait to manage sessions:

  use Symfony\CMF\Testing\PHPCRTestTrait;
  
  class PHPCRContentTest extends WebTestCase
  {
      use PHPCRTestTrait;
  
      public function testNodePersistence()
      {
          $this->assertNodeExists('/site/blog');
      }
  }
  

Gotchas and Tips

Pitfalls

1. Database State Management

   • Issue: Tests may fail due to stale data in the database (e.g., PHPCR or Doctrine).
   • Fix: Always call purgeDatabase() or clearPHPCR() before tests:

     protected function tearDown(): void
     {
         $this->clearPHPCR(); // For PHPCR-ODM
         parent::tearDown();
     }
     

   • Tip: Use transactions for faster tests:

     protected function setUp(): void
     {
         $this->beginTransaction();
     }
     
     protected function tearDown(): void
     {
         $this->rollBackTransaction();
     }
     

2. Route Caching

   • Issue: Route changes may not reflect in tests due to Symfony’s route cache.
   • Fix: Clear the cache before tests:

     public function setUp(): void
     {
         $this->clearCache();
     }
     

   • Tip: Use debug:router in tests to inspect routes:

     $this->assertContains('blog_show', $this->getRouteNames());
     

3. Content Loading Order

   • Issue: Fixtures may depend on each other, causing NotFoundException errors.
   • Fix: Load fixtures in the correct order or use dependsOn:

     $loader->load([AuthorFixture::class, BlogPostFixture::class]);
     

4. PHPCR Session Handling

   • Issue: PHPCR sessions may not be properly closed, leading to resource leaks.
   • Fix: Use PHPCRTestTrait to manage sessions:

     public function testSessionCleanup()
     {
         $this->assertSessionIsOpen();
         // Test logic
         $this->closeSession();
     }
     

Debugging Tips

• Enable Debug Mode: Add to phpunit.xml:

  <php>
      <env name="APP_ENV" value="test"/>
      <env name="APP_DEBUG" value="1"/>
  </php>
  

• Log Output: Use Symfony’s logger in tests:

  $this->log->debug('Test debug message');
  

• Dump Content: Inspect CMF content objects:

  $this->dump($content); // Uses Symfony\VarDumper\Cloner\VarCloner
  

Extension Points

1. Custom Assertions Extend base classes to add domain-specific assertions:

   trait MyCustomAssertions
   {
       protected function assertContentHasRoute(CMFContentInterface $content, string $expectedRoute)
       {
           $this->assertEquals($expectedRoute, $content->getRoute());
       }
   }
   

2. Test Data Factories Create reusable factories for CMF entities:

   class BlogPostFactory
   {
       public static function create(array $data = []): BlogPost
       {
           return (new BlogPost())
               ->setTitle($data['title'] ?? 'Default Title')
               ->setSlug($data['slug'] ?? 'default-slug');
       }
   }
   

3. Custom Test Traits Build traits for project-specific testing needs:

   trait MenuTestTrait
   {
       protected function assertMenuItemExists(string $path, string $label)
       {
           $client = static::createClient();
           $crawler = $client->request('GET', $path);
           $this->assertSelectorTextContains('a', $label);
       }
   }
   

4. Overriding Base Classes Subclass WebTestCase to enforce project-wide testing standards:

   abstract class ProjectTestCase extends WebTestCase
   {
       protected function setUp(): void
       {
           $this->enableProfiler();
           parent::setUp();
       }
   }
   

Configuration Quirks

• PHPCR Configuration: Ensure cmf_routing and cmf_core bundles are properly configured in config/packages/cmf.yaml for tests.
• Route Provider Priority: Test route providers in isolation by temporarily disabling others:

  # config/packages/test/cmf.yaml
  cmf_routing:
      dynamic_routes:
          app.route_provider:
              enabled: true
          other_provider:
              enabled: false
  

• Content Type Validation: Use assertContentType() to validate CMF content types: