fix: DockerSecretsResolver - don't normalize absolute paths like /var/www/html/...

tests/Unit/Framework/Discovery/Storage/DiscoveryCacheDeserializationTest.php

@@ -0,0 +1,233 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Attributes\Route;
+use App\Framework\Cache\Cache;
+use App\Framework\Cache\Driver\InMemoryCache;
+use App\Framework\Cache\GeneralCache;
+use App\Framework\Core\PathProvider;
+use App\Framework\DateTime\SystemClock;
+use App\Framework\Discovery\Results\DiscoveryRegistry;
+use App\Framework\Discovery\Storage\DiscoveryCacheManager;
+use App\Framework\Discovery\UnifiedDiscoveryService;
+use App\Framework\Discovery\ValueObjects\DiscoveryConfiguration;
+use App\Framework\Discovery\ValueObjects\DiscoveryContext;
+use App\Framework\Discovery\ValueObjects\DiscoveryOptions;
+use App\Framework\Discovery\ValueObjects\ScanType;
+use App\Framework\Filesystem\FileSystemService;
+use App\Framework\ReflectionLegacy\CachedReflectionProvider;
+use App\Framework\Serializer\Php\PhpSerializer;
+use App\Framework\Serializer\Php\PhpSerializerConfig;
+
+beforeEach(function () {
+    // Setup cache and services similar to DiscoveryCacheIntegrationTest
+    $cacheDriver = new InMemoryCache();
+    $serializer = new PhpSerializer(PhpSerializerConfig::safe());
+    $this->cache = new GeneralCache($cacheDriver, $serializer);
+    $this->clock = new SystemClock();
+    $this->fileSystemService = new FileSystemService();
+    $this->reflectionProvider = new CachedReflectionProvider();
+    
+    $basePath = file_exists('/var/www/html/src') ? '/var/www/html' : dirname(__DIR__, 5);
+    $this->pathProvider = new PathProvider($basePath);
+    
+    $this->discoveryContext = new DiscoveryContext(
+        paths: [$this->pathProvider->getSourcePath()->toString()],
+        scanType: ScanType::FULL,
+        options: DiscoveryOptions::default(),
+        startTime: $this->clock->now(),
+        executionContext: null
+    );
+    
+    $this->cacheManager = new DiscoveryCacheManager(
+        cache: $this->cache,
+        clock: $this->clock,
+        fileSystemService: $this->fileSystemService,
+        logger: null,
+        ttlHours: 24
+    );
+    
+    // Perform discovery to create cache
+    $configuration = new DiscoveryConfiguration(
+        paths: [$this->pathProvider->getSourcePath()],
+        useCache: true,
+        enableMemoryMonitoring: false,
+        memoryLimitMB: 128,
+        maxFilesPerBatch: 100
+    );
+    
+    $discoveryService = new UnifiedDiscoveryService(
+        pathProvider: $this->pathProvider,
+        cache: $this->cache,
+        clock: $this->clock,
+        reflectionProvider: $this->reflectionProvider,
+        configuration: $configuration
+    );
+    
+    $this->discoveredRegistry = $discoveryService->discover();
+    
+    // Store in cache
+    $this->cacheManager->store($this->discoveryContext, $this->discoveredRegistry);
+});
+
+test('discovery cache can be loaded', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    expect($cachedRegistry)->not->toBeNull()
+        ->and($cachedRegistry)->toBeInstanceOf(DiscoveryRegistry::class);
+})->skip('Requires existing cache');
+
+test('cached registry has content', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    if ($cachedRegistry === null) {
+        $this->markTestSkipped('No cached registry found - run discovery first');
+    }
+    
+    expect($cachedRegistry->hasContent())->toBeTrue()
+        ->and($cachedRegistry->isEmpty())->toBeFalse();
+});
+
+test('cached registry contains routes', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    if ($cachedRegistry === null) {
+        $this->markTestSkipped('No cached registry found - run discovery first');
+    }
+    
+    $routeClass = Route::class;
+    $routeAttributes = $cachedRegistry->attributes->get($routeClass);
+    
+    expect($routeAttributes)->toBeArray()
+        ->and(count($routeAttributes))->toBeGreaterThan(0);
+});
+
+test('route attributes are correctly deserialized', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    if ($cachedRegistry === null) {
+        $this->markTestSkipped('No cached registry found - run discovery first');
+    }
+    
+    $routeClass = Route::class;
+    $routeAttributes = $cachedRegistry->attributes->get($routeClass);
+    
+    if (empty($routeAttributes)) {
+        $this->markTestSkipped('No routes found in cache');
+    }
+    
+    $firstRoute = $routeAttributes[0];
+    
+    expect($firstRoute)->toBeInstanceOf(\App\Framework\Discovery\ValueObjects\DiscoveredAttribute::class)
+        ->and($firstRoute->className)->toBeInstanceOf(\App\Framework\Core\ValueObjects\ClassName::class)
+        ->and($firstRoute->attributeClass)->toBe($routeClass);
+});
+
+test('route attributes can create route instances', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    if ($cachedRegistry === null) {
+        $this->markTestSkipped('No cached registry found - run discovery first');
+    }
+    
+    $routeClass = Route::class;
+    $routeAttributes = $cachedRegistry->attributes->get($routeClass);
+    
+    if (empty($routeAttributes)) {
+        $this->markTestSkipped('No routes found in cache');
+    }
+    
+    $firstRoute = $routeAttributes[0];
+    
+    expect($firstRoute)->toBeInstanceOf(\App\Framework\Discovery\ValueObjects\DiscoveredAttribute::class);
+    
+    // Try to create Route instance from arguments
+    try {
+        $routeInstance = new Route(...$firstRoute->arguments);
+        expect($routeInstance)->toBeInstanceOf(Route::class);
+    } catch (\Throwable $e) {
+        $this->fail("Failed to create Route instance: {$e->getMessage()}");
+    }
+});
+
+test('registry can be serialized and deserialized', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    if ($cachedRegistry === null) {
+        $this->markTestSkipped('No cached registry found - run discovery first');
+    }
+    
+    $routeClass = Route::class;
+    $originalRouteCount = count($cachedRegistry->attributes->get($routeClass));
+    
+    // Serialize and deserialize
+    $serialized = serialize($cachedRegistry);
+    $deserialized = unserialize($serialized);
+    
+    expect($deserialized)->toBeInstanceOf(DiscoveryRegistry::class);
+    
+    $deserializedRouteCount = count($deserialized->attributes->get($routeClass));
+    
+    expect($deserializedRouteCount)->toBe($originalRouteCount);
+});
+
+test('cached registry content summary is accurate', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    if ($cachedRegistry === null) {
+        $this->markTestSkipped('No cached registry found - run discovery first');
+    }
+    
+    $summary = $cachedRegistry->getContentSummary();
+    
+    expect($summary)->toBeArray()
+        ->and($summary)->toHaveKey('routes')
+        ->and($summary)->toHaveKey('commands')
+        ->and($summary)->toHaveKey('initializers');
+    
+    // Verify route count matches actual count
+    $routeClass = Route::class;
+    $actualRouteCount = count($cachedRegistry->attributes->get($routeClass));
+    
+    expect($summary['routes'])->toBe($actualRouteCount);
+});
+
+test('all attribute types are accessible', function () {
+    $cachedRegistry = $this->cacheManager->get($this->discoveryContext);
+    
+    if ($cachedRegistry === null) {
+        $this->markTestSkipped('No cached registry found - run discovery first');
+    }
+    
+    $allTypes = $cachedRegistry->attributes->getAllTypes();
+    
+    expect($allTypes)->toBeArray();
+    
+    // Verify we can access each type
+    foreach ($allTypes as $type) {
+        $attributes = $cachedRegistry->attributes->get($type);
+        $count = $cachedRegistry->attributes->getCount($type);
+        
+        expect($attributes)->toBeArray()
+            ->and($count)->toBe(count($attributes));
+    }
+});
+
+test('cache entry can be retrieved directly', function () {
+    $cacheKey = $this->discoveryContext->getCacheKey();
+    $cacheResult = $this->cache->get($cacheKey);
+    
+    if (!$cacheResult->isHit) {
+        $this->markTestSkipped('No cache entry found - run discovery first');
+    }
+    
+    $cachedData = $cacheResult->value;
+    
+    expect($cachedData)->not->toBeNull();
+    
+    if (is_array($cachedData)) {
+        expect($cachedData)->toHaveKey('registry');
+    }
+});
+