Getting Started

Minimal Setup

Install the package in your Laravel project’s test dependencies:
```
composer require --dev eliashaeussler/deep-closure-comparator
```

Import the DeepClosureAssert class in your test file:

use EliasHaeussler\DeepClosureComparator\DeepClosureAssert;
use PHPUnit\Framework\TestCase;

Replace self::assertEquals() with DeepClosureAssert::assertEquals() for closure comparisons:
```
DeepClosureAssert::assertEquals($expectedClosure, $actualClosure);
```

First Use Case: Testing Middleware Closures

use EliasHaeussler\DeepClosureComparator\DeepClosureAssert;

public function testMiddlewareClosure()
{
    $expected = fn ($request) => $request->merge(['middleware' => 'processed']);
    $actual = fn ($request) => $request->merge(['middleware' => 'processed']);

    DeepClosureAssert::assertEquals($expected, $actual);
}

Key Files to Review

DeepClosureAssert.php: Core assertion logic and usage examples.
src/Comparator/ClosureComparator.php: Underlying comparison mechanism (uses opis/closure).
tests/: Example test cases for edge scenarios (nested closures, bound variables).

Implementation Patterns

Core Workflow: Testing Closure Equality

Define closures in your test (expected vs. actual).

Use DeepClosureAssert::assertEquals() instead of PHPUnit’s default:

// Before (fails for closures)
self::assertEquals($expected, $actual);

// After (works for closures)
DeepClosureAssert::assertEquals($expected, $actual);

Handle nested closures (e.g., closures returning closures):

$nestedExpected = fn () => fn () => 'deep';
$nestedActual = fn () => fn () => 'deep';
DeepClosureAssert::assertEquals($nestedExpected, $nestedActual);

Laravel-Specific Patterns

1. Testing Event Listeners

public function testEventListenerClosure()
{
    $expected = fn (OrderPlaced $event) => Log::info('Order placed: '.$event->id);
    $actual = app()->make(OrderPlacedListener::class)->handle(...);

    DeepClosureAssert::assertEquals($expected, $actual);
}

2. Validating Service Container Bindings

public function testServiceBindingClosure()
{
    $expected = fn () => new UserRepository();
    $actual = app()->make(UserRepository::class);

    // Compare the binding closure (if accessible)
    DeepClosureAssert::assertEquals($expected, app()->bound('App\Repositories\UserRepository') ?? null);
}

3. Middleware Pipeline Testing

public function testMiddlewareChain()
{
    $middleware = app()->make(Middleware::class);
    $expected = fn ($request) => $middleware->handle($request, fn () => 'next');

    DeepClosureAssert::assertEquals($expected, $middleware->getClosure());
}

Integration with Laravel Testing Tools

PestPHP: Wrap assertions in a custom helper:

function assertClosuresEqual($expected, $actual)
{
    DeepClosureAssert::assertEquals($expected, $actual);
}

Usage:

assertClosuresEqual(fn () => 1, fn () => 1);

Laravel Dusk: Useful for comparing JavaScript closures in Blade directives or Alpine.js callbacks.

Performance Considerations

Avoid deep comparisons in large test suites: Serializing closures (opis/closure) can be resource-intensive.
Cache comparisons: For identical closures in multiple tests, store the serialized result:
```
$serialized = \Opis\Closure\serialize($closure);
```

Gotchas and Tips

Pitfalls

PHPUnit Version Mismatch
- The package requires PHPUnit ^10.0 (as of v1.2.0). Laravel 9.x uses PHPUnit 9.x by default.
- Fix: Pin PHPUnit to ^10.0 in composer.json or use a test project to validate compatibility.
```
"require-dev": {
    "phpunit/phpunit": "^10.0",
    "eliashaeussler/deep-closure-comparator": "^1.2"
}
```
Closure Variable Capture
- Closures with bound variables (e.g., use ($user)) may fail if the variables differ in type/value.
- Workaround: Ensure bound variables are identical or use opis/closure directly:
```
$serialized1 = \Opis\Closure\serialize(fn () => $user->id);
$serialized2 = \Opis\Closure\serialize(fn () => $user->id);
self::assertEquals($serialized1, $serialized2);
```
Dynamic Closures
- Closures generated dynamically (e.g., via create_function or eval) may not serialize predictably.
- Tip: Avoid dynamic closures in tests or use opis/closure::serialize() explicitly.
Laravel-Specific Edge Cases
- Container-bound closures: If comparing closures from app()->bind(), ensure they’re not singleton instances with side effects.
- Eloquent closures: Closures referencing models may fail if the model’s state differs:
```
// ❌ Fails if $user->id differs
DeepClosureAssert::assertEquals(
    fn () => $user->name,
    fn () => $user->name
);
```
False Positives with Anonymous Functions
- Two visually identical anonymous functions may serialize differently if their closure context varies (e.g., class methods vs. standalone).
- Debugging: Use opis/closure::serialize() to inspect differences:
```
dd(\Opis\Closure\serialize($closure1), \Opis\Closure\serialize($closure2));
```

Debugging Tips

Inspect Serialized Closures

$serialized = \Opis\Closure\serialize($closure);
file_put_contents('closure_serialized.txt', $serialized);

Compare Step-by-Step Break down nested closures:

$outer1 = fn () => fn () => 'test';
$outer2 = fn () => fn () => 'test';
DeepClosureAssert::assertEquals($outer1(), $outer2()); // Compare inner closures

Use getComparator() for Custom Logic Access the underlying comparator for advanced use:

$comparator = DeepClosureAssert::getComparator();
$result = $comparator->compare($expected, $actual);

Extension Points

Custom Comparator Extend EliasHaeussler\DeepClosureComparator\Comparator\ClosureComparator to handle Laravel-specific cases:

class LaravelClosureComparator extends ClosureComparator
{
    protected function compareVariables($expected, $actual)
    {
        if ($expected instanceof Closure && $actual instanceof Closure) {
            // Add Laravel-specific logic (e.g., ignore container bindings)
            return true;
        }
        return parent::compareVariables($expected, $actual);
    }
}

DeepClosureAssert::setComparator(new LaravelClosureComparator());

Integration with Laravel’s TestCase Override createApplication() to include the package:

use EliasHaeussler\DeepClosureComparator\DeepClosureAssert;

class TestCase extends \Illuminate\Foundation\Testing\TestCase
{
    protected function setUp(): void
    {
        parent::setUp();
        DeepClosureAssert::setComparatorFactory(fn () => new ClosureComparator());
    }
}

Performance Optimization Cache serialized closures in a static map:

static $closureCache = [];

function serializeClosure(Closure $closure)
{
    $key = spl_object_hash($closure);
    return $closureCache[$key] ?? $closureCache[$key] = \Opis\Closure\serialize($closure);
}

Configuration Quirks

No config/ or service provider: The package is assertion-only; no Laravel-specific setup is required.
Dependency conflicts: Ensure opis/closure is compatible with your PHP version (v4.4+ for PHP 8.5).
PHP 8.5+: The package supports PHP 8.5, but Laravel’s default PHP version may lag. Test in a PHP 8.5 environment if needed.

Laravel-Specific Tips

Testing Closure Middleware Compare middleware closures after registration:

Deep Closure Comparator Laravel Package