Developing robust plugins for Shopware 6 requires more than writing functional code; it demands a commitment to reliability. As the ecosystem evolves toward Shopware 6.7 and beyond, unit testing becomes your first line of defense against regressions, ensuring your plugin remains stable across core updates and version upgrades. This guide explores the strategies, patterns, and best practices for writing effective unit tests in the modern Shopware plugin landscape.

Why Unit Testing Matters in Shopware 6.7

Shopware 6 relies heavily on dependency injection, the service container, and strict type systems. Plugins often interact with core services, events, and configurations. While functional tests verify end-to-end behavior, unit tests allow you to isolate business logic from external dependencies like the database or API calls.

In Shopware 6.7, performance optimizations and stricter typing standards mean your code must be precise. Unit testing helps you:

  • Catch Type Errors Early: Verify that arguments and return values match strict type declarations before runtime.
  • Speed Up Feedback Loops: Unit tests execute instantly compared to integration tests that boot the kernel, encouraging comprehensive test coverage.
  • Document Behavior: Tests serve as executable documentation for how your plugin handles edge cases and business rules.

Directory Structure and Conventions

Organize your tests following PSR-4 autoloading standards. Place them in a Tests/ directory mirroring your source structure. This separation keeps code clean and ensures PHPUnit can discover tests automatically.

src/MyPlugin/
├── Service/
│   └── DiscountCalculator.php
├── Tests/
│   └── Service/
│       └── DiscountCalculatorTest.php
├── composer.json
└── phpunit.xml (if needed for custom configurations)

Shopware 6.7 typically leverages the root phpunit.xml configuration. Ensure your plugin's composer autoloader includes test classes if required, though often tests are run directly via bin/phpunit.

Core Principles of Shopware Unit Tests

When writing unit tests for Shopware plugins, adhere to these principles:

  1. Isolation: Test a single class in isolation. Mock all dependencies using PHPUnit's built-in tools.
  2. No Global State: Never access the Shopware kernel, container, or database in a unit test. If you find yourself doing this, consider if the code should be refactored for better injectability or if an integration test is more appropriate.
  3. Arrange-Act-Assert: Structure every test method clearly: set up mocks and inputs, invoke the method under test, and assert the outcome.
  4. Strict Types: Maintain declare(strict_types=1); in both your classes and tests to align with Shopware's coding standards.

Practical Example: Testing a Custom Service

Below is an example of how to structure a unit test for a custom service. This example emphasizes mocking dependencies and validating business logic.

<?php declare(strict_types=1);

namespace MyShop\MyPlugin\Tests\Service;

use PHPUnit\Framework\TestCase;
use MyShop\MyPlugin\Service\DiscountCalculator;
use Psr\Log\LoggerInterface;

class DiscountCalculatorTest extends TestCase
{
    public function testCalculateWithPercent(): void
    {
        // Arrange: Create mocks for dependencies
        $mockLogger = $this->createMock(LoggerInterface::class);
        $calculator = new DiscountCalculator($mockLogger);

        // Act: Execute the method under test
        $result = $calculator->calculate(100.0, 20.0, 'percent');

        // Assert: Verify expected outcome using strict comparison
        static::assertSame(80.0, $result);
    }

    public function testCalculateThrowsOnInvalidDiscount(): void
    {
        $mockLogger = $this->createMock(LoggerInterface::class);
        $calculator = new DiscountCalculator($mockLogger);

        $this->expectException(\InvalidArgumentException::class);
        $calculator->calculate(100.0, 150.0, 'percent');
    }

    // Using DataProviders to test multiple scenarios efficiently
    #[\PHPUnit\Framework\Attributes\DataProvider('discountScenarios')]
    public function testCalculateWithDataProvider(float $base, float $discount, string $type, float $expected): void
    {
        $mockLogger = $this->createMock(LoggerInterface::class);
        $calculator = new DiscountCalculator($mockLogger);

        static::assertSame($expected, $calculator->calculate($base, $discount, $type));
    }

    public static function discountScenarios(): array
    {
        return [
            'ten percent off' => [100.0, 10.0, 'percent', 90.0],
            'fixed amount off' => [100.0, 25.0, 'fixed', 75.0],
            'zero discount' => [100.0, 0.0, 'percent', 100.0],
        ];
    }
}

Key Takeaways

  • Mocking Interfaces: Use $this->createMock(LoggerInterface::class) to replace dependencies you don't need to test. This ensures your test is deterministic and fast.
  • DataProvider Attribute: The #[\PHPUnit\Framework\Attributes\DataProvider('...')] attribute allows you to define multiple test cases in a single method, reducing duplication while covering various input combinations.
  • Naming Conventions: Use descriptive names like testCalculateWithPercent to clearly indicate what the test verifies.

Tackling Shopware-Specific Challenges

Mocking Plugin Context and Configuration

A common challenge in plugin development is handling the Shopware\Core\Framework\Plugin\Context, which contains configuration data. In unit tests, avoid instantiating the full context if possible. Instead, design your service to accept configuration via constructor injection or a dedicated DTO. This makes your code more testable and decoupled from Shopware internals.

If you must work with configuration in tests, pass it directly:

// Service accepting configuration
class PricingService
{
    public function __construct(private array $config) { }

    public function getBasePrice(): float
    {
        return $this->config['base_price'] ?? 0.0;
    }
}

// Test verifying config handling
public function testPriceReturnsConfigValue(): void
{
    $service = new PricingService(['base_price' => 50.0]);
    static::assertSame(50.0, $service->getBasePrice());
}

Dealing with the Service Container

Never use Container::get() or self::$container in unit tests. This couples your code to the container and breaks isolation. Use dependency injection throughout your plugin so that every class receives its dependencies via the constructor. This pattern is not only testable but also aligns with Shopware 6.7's emphasis on clean architecture.

Shopware 6.7 Testing Updates and Best Practices

As you develop for Shopware 6.7 or beyond, keep the following in mind:

  • PHP Version Compatibility: Ensure your tests utilize features supported by the PHP version required by your Shopware installation (typically PHP 8.1 or 8.2). Leverage modern PHPUnit attributes for data providers and annotations where available.
  • PHPUnit Versioning: Shopware 6.7 may require specific PHPUnit versions. Check the compatibility matrix in composer.json to ensure your test suite runs correctly.
  • Attribute Support: Use PHP attributes extensively for test configuration, such as #[DataProvider], #[TestWith], and #[CoversClass]. This improves code readability and maintainability.
  • CI/CD Integration: Integrate bin/phpunit into your pipeline. Automated testing is essential for maintaining quality when merging changes or upgrading Shopware versions.

Common Pitfalls to Avoid

  1. Testing Implementation Details: Focus on public behavior rather than private methods. Testing internal logic makes refactoring difficult and brittle tests more likely.
  2. Over-Mocking: Mock only external dependencies. Do not mock classes you own; test their actual implementation instead.
  3. Ignoring Edge Cases: Test boundary conditions, null values, and exception paths to ensure your plugin behaves gracefully under all circumstances.
  4. Slow Tests: If a test performs file I/O or database access, it is likely an integration test. Keep unit tests fast by mocking I/O operations.

Conclusion

Writing unit tests for Shopware 6 plugins is an investment in long-term maintainability and code quality. By isolating logic, mocking dependencies, and adhering to Shopware's coding standards, you create a safety net that empowers you to refactor and extend your plugin with confidence. As the platform advances toward Shopware 8 and beyond, a robust test suite will ensure your plugins remain compatible, performant, and reliable. Start small, test critical paths, and let your tests drive the excellence of your Shopware 6.7 development workflow.