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

tests/Framework/Discovery/Storage/DiscoveryCacheManagerRefactoredTest.php

@@ -0,0 +1,209 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\Discovery\Storage;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Cache\CacheItem;
+use App\Framework\Cache\CacheKey;
+use App\Framework\Cache\Driver\InMemoryCache;
+use App\Framework\Cache\GeneralCache;
+use App\Framework\Core\ValueObjects\Byte;
+use App\Framework\DateTime\Clock;
+use App\Framework\DateTime\SystemClock;
+use App\Framework\Discovery\Results\AttributeRegistry;
+use App\Framework\Discovery\Results\DiscoveryRegistry;
+use App\Framework\Discovery\Results\InterfaceRegistry;
+use App\Framework\Discovery\Results\TemplateRegistry;
+use App\Framework\Discovery\Storage\DiscoveryCacheManager;
+use App\Framework\Discovery\Storage\Services\CacheEntrySerializer;
+use App\Framework\Discovery\Storage\Services\CacheEntryUpgrader;
+use App\Framework\Discovery\Storage\Services\CacheEntryValidator;
+use App\Framework\Discovery\Storage\Services\StalenessChecker;
+use App\Framework\Core\ValueObjects\Timestamp;
+use App\Framework\Discovery\Storage\ValueObjects\CacheEntry;
+use App\Framework\Discovery\Storage\ValueObjects\CacheRetrievalResult;
+use App\Framework\Discovery\Storage\ValueObjects\CacheStorageResult;
+use App\Framework\Discovery\ValueObjects\CacheLevel;
+use App\Framework\Discovery\ValueObjects\CacheTier;
+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\Serializer\Php\PhpSerializer;
+use App\Framework\Serializer\Php\PhpSerializerConfig;
+
+describe('DiscoveryCacheManager - Refactored Implementation', function () {
+    beforeEach(function () {
+        $cacheDriver = new InMemoryCache();
+        $serializer = new PhpSerializer(PhpSerializerConfig::safe());
+        $this->cache = new GeneralCache($cacheDriver, $serializer);
+        $this->clock = new SystemClock();
+        $this->fileSystemService = new FileSystemService();
+
+        // Use a real existing path but with future time to avoid stale detection
+        // This prevents the test from triggering actual discovery while allowing staleness checks
+        $basePath = file_exists('/var/www/html/src') ? '/var/www/html/src' : __DIR__ . '/../../../../src';
+        $testPath = $basePath;
+
+        // Use a future time to avoid stale detection issues
+        $futureTime = new \DateTimeImmutable('2099-01-01 00:00:00');
+        $this->testContext = new DiscoveryContext(
+            paths: [$testPath],
+            scanType: ScanType::FULL,
+            options: new DiscoveryOptions(),
+            startTime: $futureTime
+        );
+
+        $this->testRegistry = new DiscoveryRegistry(
+            attributes: new AttributeRegistry(),
+            interfaces: new InterfaceRegistry(),
+            templates: new TemplateRegistry()
+        );
+
+        // Create cache manager with new services
+        $this->cacheManager = new DiscoveryCacheManager(
+            cache: $this->cache,
+            clock: $this->clock,
+            fileSystemService: $this->fileSystemService,
+            serializer: new CacheEntrySerializer(),
+            stalenessChecker: new StalenessChecker($this->fileSystemService),
+            validator: new CacheEntryValidator(),
+            upgrader: new CacheEntryUpgrader()
+        );
+    });
+
+    it('stores registry using new CacheEntry structure', function () {
+        $success = $this->cacheManager->store($this->testContext, $this->testRegistry);
+
+        expect($success)->toBeTrue();
+
+        // Debug: Check what's in cache
+        $key = $this->testContext->getCacheKey();
+        $result = $this->cache->get($key);
+        $item = $result->getItem($key);
+        
+        expect($item->isHit)->toBeTrue('Cache item should be hit');
+        
+        // Verify cache structure
+        $cacheData = $item->value;
+        expect(is_array($cacheData))->toBeTrue('Cache data should be array');
+        expect(isset($cacheData['registry']))->toBeTrue('Cache should have registry');
+        expect(isset($cacheData['startTime']))->toBeTrue('Cache should have startTime');
+        expect(isset($cacheData['version']))->toBeTrue('Cache should have version');
+        
+        // Verify cache contains the data
+        $cached = $this->cacheManager->get($this->testContext);
+        expect($cached)->not->toBeNull('Cached registry should not be null');
+        expect($cached)->toBeInstanceOf(DiscoveryRegistry::class);
+        expect($cached->isEmpty())->toBe($this->testRegistry->isEmpty());
+    });
+
+    it('retrieves cached registry using new services', function () {
+        // Store first
+        $this->cacheManager->store($this->testContext, $this->testRegistry);
+
+        // Retrieve
+        $cached = $this->cacheManager->get($this->testContext);
+
+        expect($cached)->toBeInstanceOf(DiscoveryRegistry::class);
+        expect($cached->isEmpty())->toBe($this->testRegistry->isEmpty());
+    });
+
+    it('handles cache miss correctly', function () {
+        // Don't store anything
+        $cached = $this->cacheManager->get($this->testContext);
+
+        expect($cached)->toBeNull();
+    });
+
+    it('stores and retrieves with version information', function () {
+        $success = $this->cacheManager->store($this->testContext, $this->testRegistry);
+        expect($success)->toBeTrue();
+
+        // Retrieve should work
+        $cached = $this->cacheManager->get($this->testContext);
+        expect($cached)->toBeInstanceOf(DiscoveryRegistry::class);
+    });
+
+    it('handles cache invalidation', function () {
+        // Store
+        $this->cacheManager->store($this->testContext, $this->testRegistry);
+
+        // Invalidate
+        $invalidated = $this->cacheManager->invalidate($this->testContext);
+        expect($invalidated)->toBeTrue();
+
+        // Should not be retrievable
+        $cached = $this->cacheManager->get($this->testContext);
+        expect($cached)->toBeNull();
+    });
+
+    it('uses CacheEntrySerializer for serialization', function () {
+        $success = $this->cacheManager->store($this->testContext, $this->testRegistry);
+        expect($success)->toBeTrue();
+
+        // Verify cache contains serialized CacheEntry structure
+        $key = $this->testContext->getCacheKey();
+        $result = $this->cache->get($key);
+        $item = $result->getItem($key);
+
+        expect($item->isHit)->toBeTrue();
+        
+        // Data should be an array (serialized CacheEntry)
+        $data = $item->value;
+        expect(is_array($data))->toBeTrue();
+        expect(isset($data['registry']))->toBeTrue();
+        expect(isset($data['version']))->toBeTrue();
+    });
+
+    it('uses StalenessChecker for staleness detection', function () {
+        // Store with future time
+        $this->cacheManager->store($this->testContext, $this->testRegistry);
+
+        // Retrieve should work (cache is fresh)
+        $cached = $this->cacheManager->get($this->testContext);
+        expect($cached)->toBeInstanceOf(DiscoveryRegistry::class);
+    });
+
+    it('handles incremental scans as stale', function () {
+        // Store first
+        $this->cacheManager->store($this->testContext, $this->testRegistry);
+
+        // Create incremental context
+        $incrementalContext = new DiscoveryContext(
+            paths: $this->testContext->paths,
+            scanType: ScanType::INCREMENTAL,
+            options: new DiscoveryOptions(),
+            startTime: $this->testContext->startTime
+        );
+
+        // Should return null (stale)
+        $cached = $this->cacheManager->get($incrementalContext);
+        expect($cached)->toBeNull();
+    });
+
+    it('uses CacheEntryValidator for validation', function () {
+        // Store valid data
+        $this->cacheManager->store($this->testContext, $this->testRegistry);
+
+        // Should retrieve successfully
+        $cached = $this->cacheManager->get($this->testContext);
+        expect($cached)->toBeInstanceOf(DiscoveryRegistry::class);
+    });
+
+    it('uses CacheEntryUpgrader for old format migration', function () {
+        // Store old format directly (just DiscoveryRegistry)
+        $key = $this->testContext->getCacheKey();
+        $oldFormatItem = CacheItem::forSet($key, $this->testRegistry);
+        $this->cache->set($oldFormatItem);
+
+        // Retrieve should upgrade automatically
+        $cached = $this->cacheManager->get($this->testContext);
+        
+        // Should work (upgraded)
+        expect($cached)->toBeInstanceOf(DiscoveryRegistry::class);
+    });
+});
+