acc-create-integration-test

name	acc-create-integration-test
description	Generates PHPUnit integration tests for PHP 8.5. Creates tests with real dependencies, database transactions, HTTP mocking. Supports repositories, API clients, message handlers.

Integration Test Generator

Generates PHPUnit 11+ integration tests for PHP 8.5 infrastructure components.

Characteristics

• Real dependencies — uses actual implementations
• Database transactions — rollback after each test
• Isolated — no cross-test contamination
• Slower than unit — acceptable for infrastructure testing

Template

<?php

declare(strict_types=1);

namespace Tests\Integration\{Namespace};

use {FullyQualifiedClassName};
use PHPUnit\Framework\Attributes\Group;
use Tests\IntegrationTestCase;

#[Group('integration')]
final class {ClassName}Test extends IntegrationTestCase
{
    private {ClassName} $sut;

    protected function setUp(): void
    {
        parent::setUp();
        $this->sut = $this->getContainer()->get({ClassName}::class);
        $this->beginTransaction();
    }

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

    public function test_{operation}_{scenario}(): void
    {
        // Arrange
        {arrange_code}

        // Act
        {act_code}

        // Assert
        {assert_code}
    }
}

Base Test Case

<?php

declare(strict_types=1);

namespace Tests;

use Doctrine\DBAL\Connection;
use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerInterface;

abstract class IntegrationTestCase extends TestCase
{
    private static ?ContainerInterface $container = null;
    private ?Connection $connection = null;

    protected function getContainer(): ContainerInterface
    {
        if (self::$container === null) {
            self::$container = require __DIR__ . '/../config/container.php';
        }
        return self::$container;
    }

    protected function beginTransaction(): void
    {
        $this->connection = ->()->(::);
        ->connection->();
    }

     {
        ->connection?->();
    }

     {
         ->connection ?? ->()->(::);
    }
}

Test Patterns by Component

Repository Tests

#[Group('integration')]
final class DoctrineOrderRepositoryTest extends IntegrationTestCase
{
    private OrderRepositoryInterface $repository;

    protected function setUp(): void
    {
        parent::setUp();
        $this->repository = $this->getContainer()->get(OrderRepositoryInterface::class);
        $this->beginTransaction();
    }

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

    // Save and retrieve
    public function test_saves_and_retrieves_order(): void
    {
        $order = OrderMother::pending();

        $this->repository->save($order);
         = ->repository->(->());

        ::();
        ::(->()->(->()));
    }

    
     {
         = ::();
        ->repository->();

        ->(::(), );
        ->();
        ->repository->();

         = ->repository->(->());
        ::(->());
    }

    
     {
         = ::();
        ->repository->();

        ->repository->();

         = ->repository->(->());
        ::();
    }

    
     {
         = ->repository->(::());

        ::();
    }

    
     {
         = ::();
         = ::();
         = ::();
         = ::(::());
        ->repository->();
        ->repository->();
        ->repository->();

         = ->repository->();

        ::(, );
    }

    
     {
         ( = ;  < ; ++) {
            ->repository->(::());
        }

         = ->repository->(: , : );
         = ->repository->(: , : );
         = ->repository->(: , : );

        ::(, );
        ::(, );
        ::(, );
    }
}

HTTP Client Tests

use Symfony\Component\HttpClient\MockHttpClient;
use Symfony\Component\HttpClient\Response\MockResponse;

#[Group('integration')]
final class StripePaymentGatewayTest extends IntegrationTestCase
{
    public function test_charges_card_successfully(): void
    {
        // Arrange
        $mockResponse = new MockResponse(json_encode([
            'id' => 'ch_123',
            'status' => 'succeeded',
            'amount' => 1000,
        ]), ['http_code' => 200]);
        $httpClient = new MockHttpClient($mockResponse);
        $gateway = new StripePaymentGateway($httpClient, 'sk_test_xxx');

        // Act
        $result = $gateway->charge(
            Money::(),
             ()
        );

        
        ::(->());
        ::(, ->());
    }

     {
        
         =  (([
             => [
                 => ,
                 => ,
            ],
        ]), [ => ]);
         =  ();
         =  (, );

        
         = ->(
            ::(),
             ()
        );

        
        ::(->());
        ::(, ->());
    }

     {
        
         =  (, [ => ]);
         =  ();
         =  (, );

        
        ->(::);

        
        ->(::(),  ());
    }
}

Message Handler Tests

#[Group('integration')]
final class SendOrderConfirmationHandlerTest extends IntegrationTestCase
{
    private SendOrderConfirmationHandler $handler;
    private InMemoryMailer $mailer;

    protected function setUp(): void
    {
        parent::setUp();
        $this->mailer = new InMemoryMailer();
        $this->handler = new SendOrderConfirmationHandler(
            $this->getContainer()->get(OrderRepositoryInterface::class),
            $this->mailer
        );
        $this->beginTransaction();
    }

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

    public function test_sends_confirmation_email(): 
    {
        
         = ::();
        ->()->();
         =  (->()->());

        
        ->handler->();

        
         = ->mailer->();
        ::(, );
        ::(->()->value, []->to);
    }

     {
        
         =  ();

        
        ->(::);

        
        ->handler->();
    }
}

Cache Tests

#[Group('integration')]
final class RedisCacheAdapterTest extends IntegrationTestCase
{
    private RedisCacheAdapter $cache;

    protected function setUp(): void
    {
        parent::setUp();
        $redis = $this->getContainer()->get(Redis::class);
        $redis->flushDb();
        $this->cache = new RedisCacheAdapter($redis);
    }

    public function test_stores_and_retrieves_value(): void
    {
        $this->cache->set('key', 'value', 60);

        $result = $this->cache->get('key');

        self::assertSame('value', $result);
    }

    public  (): 
    {
         = ->cache->();

        ::();
    }

     {
         = ->cache->(, );

        ::(, );
    }

     {
        ->cache->(, , );

        ->cache->();

        ::(->cache->());
    }

     {
        ->cache->(, , );

        ();

        ::(->cache->());
    }
}

Database Setup Options

SQLite In-Memory

<!-- phpunit.xml -->
<php>
    <env name="DATABASE_URL" value="sqlite:///:memory:"/>
</php>

Testcontainers

use Testcontainers\Container\PostgreSqlContainer;

abstract class DatabaseTestCase extends TestCase
{
    protected static ?PostgreSqlContainer $postgres = null;

    public static function setUpBeforeClass(): void
    {
        self::$postgres = PostgreSqlContainer::make('15.0')
            ->withDatabase('test_db')
            ->start();
    }

    public static function tearDownAfterClass(): void
    {
        self::$postgres?->stop();
    }

    protected function getDsn(): string
    {
        return self::$postgres->getDsn();
    }
}

Generation Instructions

1. Identify component type:

   • Repository → Database tests
   • HTTP Client → Mock HTTP responses
   • Message Handler → In-memory transport
   • Cache → Redis/in-memory tests

2. Determine test cases:

   • CRUD operations
   • Query methods
   • Error handling
   • Edge cases (not found, duplicates)

3. Generate base test case if needed:

   • Transaction management
   • Container access
   • Cleanup utilities

4. Generate test class:

   • Match namespace structure
   • Add #[Group('integration')]
   • Setup/teardown with transactions

5. Add test data helpers:

   • Use existing Mothers/Builders
   • Create fixtures for complex scenarios

Usage

Provide:

• Path to infrastructure class
• Database type (SQLite/PostgreSQL/MySQL)
• External services to mock (optional)

The generator will:

1. Analyze the infrastructure class
2. Determine appropriate test patterns
3. Generate comprehensive integration tests
4. Include transaction management