7a:Tf5e,// Bad: Cache logic embedded directly in service class ProductService { private redisClient: RedisClient; async getProduct(id: string): Promise { // Cache check hardcoded - impossible to test without Redis const cached = await this.redisClient.get(`product:${id}`); if (cached) { return JSON.parse(cached); } const product = await this.database.find(id); await this.redisClient.setex(`product:${id}`, 3600, JSON.stringify(product)); return product; } } // Good: Cache abstraction enables testing interface Cache { get(key: string): Promise; set(key: string, value: T, ttlSeconds?: number): Promise; delete(key: string): Promise; clear(): Promise; } // In-memory implementation for testing class InMemoryCache implements Cache { private store = new Map(); // Track operations for test assertions public operations: { type: string; key: string; timestamp: number }[] = []; async get(key: string): Promise { this.operations.push({ type: 'get', key, timestamp: Date.now() }); const entry = this.store.get(key); if (!entry) return null; if (entry.expiresAt && Date.now() > entry.expiresAt) { this.store.delete(key); return null; } return entry.value; } async set(key: string, value: T, ttlSeconds?: number): Promise { this.operations.push({ type: 'set', key, timestamp: Date.now() }); const expiresAt = ttlSeconds ? Date.now() + (ttlSeconds * 1000) : null; this.store.set(key, { value, expiresAt }); } async delete(key: string): Promise { this.operations.push({ type: 'delete', key, timestamp: Date.now() }); this.store.delete(key); } async clear(): Promise { this.operations.push({ type: 'clear', key: '*', timestamp: Date.now() }); this.store.clear(); } // Test helper: forcibly expire an entry expireEntry(key: string): void { const entry = this.store.get(key); if (entry) { entry.expiresAt = Date.now() - 1; } } // Test helper: check if key exists (bypassing expiry check) hasEntry(key: string): boolean { return this.store.has(key); } } // Redis implementation for production class RedisCache implements Cache { constructor(private client: RedisClient) {} async get(key: string): Promise { const data = await this.client.get(key); return data ? JSON.parse(data) : null; } async set(key: string, value: T, ttlSeconds?: number): Promise { const serialized = JSON.stringify(value); if (ttlSeconds) { await this.client.setex(key, ttlSeconds, serialized); } else { await this.client.set(key, serialized); } } async delete(key: string): Promise { await this.client.del(key); } async clear(): Promise { await this.client.flushdb(); } } // Service now accepts cache as dependency class ProductService { constructor( private cache: Cache, private database: ProductDatabase, private metrics: MetricsCollector ) {} async getProduct(id: string): Promise { const cacheKey = `product:${id}`; const cached = await this.cache.get(cacheKey); if (cached) { this.metrics.recordCacheHit('product'); return cached; } this.metrics.recordCacheMiss('product'); const product = await this.database.find(id); await this.cache.set(cacheKey, product, 3600); return product; } }7b:Teda,// Bad: Cache logic embedded directly in service public class ProductService { private final RedisClient redisClient; public Product getProduct(String id) { // Cache check hardcoded - impossible to test without Redis String cached = redisClient.get("product:" + id); if (cached != null) { return objectMapper.readValue(cached, Product.class); } Product product = database.find(id); redisClient.setex("product:" + id, 3600, objectMapper.writeValueAsString(product)); return product; } } // Good: Cache abstraction enables testing public interface Cache { Optional get(String key); void set(String key, T value, Duration ttl); void delete(String key); void clear(); } // In-memory implementation for testing public class InMemoryCache implements Cache { private final Map> store = new ConcurrentHashMap<>(); // Track operations for test assertions private final List operations = new ArrayList<>(); @Override public Optional get(String key) { operations.add(new CacheOperation("get", key, Instant.now())); CacheEntry entry = store.get(key); if (entry == null) return Optional.empty(); if (entry.isExpired()) { store.remove(key); return Optional.empty(); } return Optional.of(entry.getValue()); } @Override public void set(String key, T value, Duration ttl) { operations.add(new CacheOperation("set", key, Instant.now())); Instant expiresAt = ttl != null ? Instant.now().plus(ttl) : null; store.put(key, new CacheEntry<>(value, expiresAt)); } @Override public void delete(String key) { operations.add(new CacheOperation("delete", key, Instant.now())); store.remove(key); } @Override public void clear() { operations.add(new CacheOperation("clear", "*", Instant.now())); store.clear(); } // Test helper: forcibly expire an entry public void expireEntry(String key) { CacheEntry entry = store.get(key); if (entry != null) { store.put(key, new CacheEntry<>(entry.getValue(), Instant.now().minusSeconds(1))); } } public List getOperations() { return Collections.unmodifiableList(operations); } private static class CacheEntry { private final T value; private final Instant expiresAt; CacheEntry(T value, Instant expiresAt) { this.value = value; this.expiresAt = expiresAt; } boolean isExpired() { return expiresAt != null && Instant.now().isAfter(expiresAt); } T getValue() { return value; } } } // Service now accepts cache as dependency public class ProductService { private final Cache cache; private final ProductDatabase database; private final MetricsCollector metrics; public ProductService(Cache cache, ProductDatabase database, MetricsCollector metrics) { this.cache = cache; this.database = database; this.metrics = metrics; } public Product getProduct(String id) { String cacheKey = "product:" + id; Optional cached = cache.get(cacheKey); if (cached.isPresent()) { metrics.recordCacheHit("product"); return cached.get(); } metrics.recordCacheMiss("product"); Product product = database.find(id); cache.set(cacheKey, product, Duration.ofHours(1)); return product; } }7c:T16c7,import { describe, it, expect, beforeEach, vi } from 'vitest'; import { InMemoryCache } from './InMemoryCache'; import { ProductService } from './ProductService'; import { MockProductDatabase } from './mocks/MockProductDatabase'; import { MockMetricsCollector } from './mocks/MockMetricsCollector'; describe('ProductService Cache Behavior', () => { let cache: InMemoryCache; let database: MockProductDatabase; let metrics: MockMetricsCollector; let service: ProductService; beforeEach(() => { // Fresh instances for each test - no state pollution cache = new InMemoryCache(); database = new MockProductDatabase(); metrics = new MockMetricsCollector(); service = new ProductService(cache, database, metrics); }); describe('Cache Miss Behavior', () => { it('should fetch from database on cache miss', async () => { const expectedProduct = { id: 'prod-1', name: 'Widget', price: 29.99 }; database.setProduct('prod-1', expectedProduct); const result = await service.getProduct('prod-1'); expect(result).toEqual(expectedProduct); expect(database.queryCount).toBe(1); }); it('should populate cache after database fetch', async () => { const expectedProduct = { id: 'prod-1', name: 'Widget', price: 29.99 }; database.setProduct('prod-1', expectedProduct); await service.getProduct('prod-1'); // Verify cache was populated const cached = await cache.get('product:prod-1'); expect(cached).toEqual(expectedProduct); }); it('should record cache miss metric', async () => { database.setProduct('prod-1', { id: 'prod-1', name: 'Widget', price: 29.99 }); await service.getProduct('prod-1'); expect(metrics.getCacheMisses('product')).toBe(1); expect(metrics.getCacheHits('product')).toBe(0); }); }); describe('Cache Hit Behavior', () => { it('should return cached data without database query', async () => { const cachedProduct = { id: 'prod-1', name: 'Cached Widget', price: 19.99 }; await cache.set('product:prod-1', cachedProduct, 3600); const result = await service.getProduct('prod-1'); expect(result).toEqual(cachedProduct); expect(database.queryCount).toBe(0); // No database hit }); it('should record cache hit metric', async () => { await cache.set('product:prod-1', { id: 'prod-1', name: 'Widget', price: 29.99 }, 3600); await service.getProduct('prod-1'); expect(metrics.getCacheHits('product')).toBe(1); expect(metrics.getCacheMisses('product')).toBe(0); }); it('should serve cache hit even if database has different data', async () => { // This verifies cache takes precedence const cachedProduct = { id: 'prod-1', name: 'Cached Version', price: 19.99 }; const databaseProduct = { id: 'prod-1', name: 'Database Version', price: 29.99 }; await cache.set('product:prod-1', cachedProduct, 3600); database.setProduct('prod-1', databaseProduct); const result = await service.getProduct('prod-1'); expect(result.name).toBe('Cached Version'); }); }); describe('TTL Expiration', () => { it('should treat expired entry as cache miss', async () => { const product = { id: 'prod-1', name: 'Widget', price: 29.99 }; await cache.set('product:prod-1', product, 3600); database.setProduct('prod-1', product); // Force expiration using test helper cache.expireEntry('product:prod-1'); await service.getProduct('prod-1'); // Should have queried database due to expiration expect(database.queryCount).toBe(1); expect(metrics.getCacheMisses('product')).toBe(1); }); it('should refresh cache after TTL expiration', async () => { const oldProduct = { id: 'prod-1', name: 'Old Widget', price: 19.99 }; const newProduct = { id: 'prod-1', name: 'New Widget', price: 29.99 }; await cache.set('product:prod-1', oldProduct, 3600); database.setProduct('prod-1', newProduct); cache.expireEntry('product:prod-1'); const result = await service.getProduct('prod-1'); expect(result.name).toBe('New Widget'); }); }); describe('Cache Operation Tracking', () => { it('should perform get then set on cache miss', async () => { database.setProduct('prod-1', { id: 'prod-1', name: 'Widget', price: 29.99 }); await service.getProduct('prod-1'); const ops = cache.operations; expect(ops.length).toBe(2); expect(ops[0].type).toBe('get'); expect(ops[1].type).toBe('set'); }); it('should perform only get on cache hit', async () => { await cache.set('product:prod-1', { id: 'prod-1', name: 'Widget', price: 29.99 }, 3600); cache.operations.length = 0; // Clear setup operations await service.getProduct('prod-1'); const ops = cache.operations; expect(ops.length).toBe(1); expect(ops[0].type).toBe('get'); }); }); });7d:T16b5,import org.junit.jupiter.api.*; import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; class ProductServiceCacheTest { private InMemoryCache cache; private ProductDatabase database; private MetricsCollector metrics; private ProductService service; @BeforeEach void setUp() { cache = new InMemoryCache<>(); database = mock(ProductDatabase.class); metrics = new InMemoryMetricsCollector(); service = new ProductService(cache, database, metrics); } @Nested @DisplayName("Cache Miss Behavior") class CacheMissBehavior { @Test @DisplayName("should fetch from database on cache miss") void shouldFetchFromDatabaseOnCacheMiss() { Product expected = new Product("prod-1", "Widget", 29.99); when(database.find("prod-1")).thenReturn(expected); Product result = service.getProduct("prod-1"); assertThat(result).isEqualTo(expected); verify(database, times(1)).find("prod-1"); } @Test @DisplayName("should populate cache after database fetch") void shouldPopulateCacheAfterFetch() { Product expected = new Product("prod-1", "Widget", 29.99); when(database.find("prod-1")).thenReturn(expected); service.getProduct("prod-1"); Optional cached = cache.get("product:prod-1"); assertThat(cached).isPresent().contains(expected); } @Test @DisplayName("should record cache miss metric") void shouldRecordCacheMissMetric() { when(database.find(anyString())).thenReturn(new Product("prod-1", "Widget", 29.99)); service.getProduct("prod-1"); assertThat(metrics.getCacheMisses("product")).isEqualTo(1); assertThat(metrics.getCacheHits("product")).isEqualTo(0); } } @Nested @DisplayName("Cache Hit Behavior") class CacheHitBehavior { @Test @DisplayName("should return cached data without database query") void shouldReturnCachedDataWithoutDatabaseQuery() { Product cached = new Product("prod-1", "Cached Widget", 19.99); cache.set("product:prod-1", cached, Duration.ofHours(1)); Product result = service.getProduct("prod-1"); assertThat(result).isEqualTo(cached); verifyNoInteractions(database); } @Test @DisplayName("should record cache hit metric") void shouldRecordCacheHitMetric() { cache.set("product:prod-1", new Product("prod-1", "Widget", 29.99), Duration.ofHours(1)); service.getProduct("prod-1"); assertThat(metrics.getCacheHits("product")).isEqualTo(1); assertThat(metrics.getCacheMisses("product")).isEqualTo(0); } @Test @DisplayName("should serve cache even when database has different data") void shouldServeCacheOverDatabase() { Product cachedProduct = new Product("prod-1", "Cached Version", 19.99); cache.set("product:prod-1", cachedProduct, Duration.ofHours(1)); // Database should NOT be called, so this data should not be returned when(database.find("prod-1")).thenReturn(new Product("prod-1", "DB Version", 29.99)); Product result = service.getProduct("prod-1"); assertThat(result.getName()).isEqualTo("Cached Version"); verifyNoInteractions(database); } } @Nested @DisplayName("TTL Expiration") class TtlExpiration { @Test @DisplayName("should treat expired entry as cache miss") void shouldTreatExpiredEntryAsCacheMiss() { Product product = new Product("prod-1", "Widget", 29.99); cache.set("product:prod-1", product, Duration.ofHours(1)); when(database.find("prod-1")).thenReturn(product); // Force expiration cache.expireEntry("product:prod-1"); service.getProduct("prod-1"); verify(database, times(1)).find("prod-1"); assertThat(metrics.getCacheMisses("product")).isEqualTo(1); } @Test @DisplayName("should refresh cache after expiration") void shouldRefreshCacheAfterExpiration() { Product oldProduct = new Product("prod-1", "Old Widget", 19.99); Product newProduct = new Product("prod-1", "New Widget", 29.99); cache.set("product:prod-1", oldProduct, Duration.ofHours(1)); when(database.find("prod-1")).thenReturn(newProduct); cache.expireEntry("product:prod-1"); Product result = service.getProduct("prod-1"); assertThat(result.getName()).isEqualTo("New Widget"); } } @Nested @DisplayName("Cache Operation Tracking") class CacheOperationTracking { @Test @DisplayName("should perform get then set on cache miss") void shouldPerformGetThenSetOnCacheMiss() { when(database.find("prod-1")).thenReturn(new Product("prod-1", "Widget", 29.99)); service.getProduct("prod-1"); List ops = cache.getOperations(); assertThat(ops).hasSize(2); assertThat(ops.get(0).getType()).isEqualTo("get"); assertThat(ops.get(1).getType()).isEqualTo("set"); } } }7e:T18f3,describe('Cache Invalidation', () => { let cache: InMemoryCache; let productService: ProductService; let catalogService: CatalogService; beforeEach(() => { cache = new InMemoryCache(); // Services share the same cache instance productService = new ProductService(cache, mockDatabase, mockMetrics); catalogService = new CatalogService(cache, mockDatabase); }); describe('Direct Invalidation', () => { it('should invalidate cache entry when product is updated', async () => { // Arrange: Cache a product const originalProduct = { id: 'prod-1', name: 'Original', price: 29.99 }; await cache.set('product:prod-1', originalProduct, 3600); // Act: Update the product (which should invalidate cache) const updatedProduct = { id: 'prod-1', name: 'Updated', price: 39.99 }; mockDatabase.setProduct('prod-1', updatedProduct); await productService.updateProduct('prod-1', updatedProduct); // Assert: Cache entry should be invalidated const cached = await cache.get('product:prod-1'); expect(cached).toBeNull(); }); it('should serve fresh data after invalidation', async () => { // Arrange await cache.set('product:prod-1', { id: 'prod-1', name: 'Cached', price: 29.99 }, 3600); const freshProduct = { id: 'prod-1', name: 'Fresh from DB', price: 49.99 }; mockDatabase.setProduct('prod-1', freshProduct); // Act: Invalidate then fetch await productService.invalidateProductCache('prod-1'); const result = await productService.getProduct('prod-1'); // Assert expect(result.name).toBe('Fresh from DB'); expect(mockDatabase.queryCount).toBe(1); }); }); describe('Cascading Invalidation', () => { it('should invalidate product listings when product is updated', async () => { // Arrange: Cache both product and category listing containing it await cache.set('product:prod-1', { id: 'prod-1', name: 'Widget' }, 3600); await cache.set('category:electronics:products', [ { id: 'prod-1', name: 'Widget' }, { id: 'prod-2', name: 'Gadget' } ], 3600); // Act: Update product await productService.updateProduct('prod-1', { id: 'prod-1', name: 'Super Widget' }); // Assert: Both caches should be invalidated expect(await cache.get('product:prod-1')).toBeNull(); expect(await cache.get('category:electronics:products')).toBeNull(); }); it('should invalidate all product caches when category is deleted', async () => { // Arrange: Cache multiple products in a category await cache.set('product:prod-1', { id: 'prod-1', categoryId: 'cat-1' }, 3600); await cache.set('product:prod-2', { id: 'prod-2', categoryId: 'cat-1' }, 3600); await cache.set('product:prod-3', { id: 'prod-3', categoryId: 'cat-2' }, 3600); // Act: Delete category await catalogService.deleteCategory('cat-1'); // Assert: Products in deleted category should be invalidated expect(await cache.get('product:prod-1')).toBeNull(); expect(await cache.get('product:prod-2')).toBeNull(); // Product in different category should remain cached expect(await cache.get('product:prod-3')).not.toBeNull(); }); }); describe('Pattern-Based Invalidation', () => { it('should invalidate all matching keys for pattern', async () => { // Arrange: Cache various keys await cache.set('user:123:profile', { name: 'John' }, 3600); await cache.set('user:123:preferences', { theme: 'dark' }, 3600); await cache.set('user:123:sessions', ['sess-1', 'sess-2'], 3600); await cache.set('user:456:profile', { name: 'Jane' }, 3600); // Act: Invalidate all caches for user 123 await cache.deletePattern('user:123:*'); // Assert expect(await cache.get('user:123:profile')).toBeNull(); expect(await cache.get('user:123:preferences')).toBeNull(); expect(await cache.get('user:123:sessions')).toBeNull(); // Other users unaffected expect(await cache.get('user:456:profile')).not.toBeNull(); }); }); describe('Version-Based Invalidation', () => { it('should miss cache when version changes', async () => { const versionedCache = new VersionedCache(cache); // Arrange: Cache with version 1 versionedCache.setVersion('products', 1); await versionedCache.set('product:prod-1', { id: 'prod-1', name: 'v1' }, 3600); // Act: Increment version (simulates schema change or bulk refresh) versionedCache.setVersion('products', 2); // Assert: Old cached data is not returned const result = await versionedCache.get('product:prod-1'); expect(result).toBeNull(); }); }); }); // Example versioned cache wrapper class VersionedCache { private versions: Map = new Map(); constructor(private innerCache: Cache<{ version: number; data: T }>) {} setVersion(namespace: string, version: number): void { this.versions.set(namespace, version); } async get(key: string): Promise { const namespace = key.split(':')[0]; const currentVersion = this.versions.get(namespace) || 0; const entry = await this.innerCache.get(key); if (!entry || entry.version !== currentVersion) { return null; } return entry.data; } async set(key: string, value: T, ttlSeconds: number): Promise { const namespace = key.split(':')[0]; const version = this.versions.get(namespace) || 0; await this.innerCache.set(key, { version, data: value }, ttlSeconds); } }7f:T168b,import { GenericContainer, StartedTestContainer } from 'testcontainers'; import { createClient, RedisClientType } from 'redis'; describe('ProductService Redis Integration', () => { let redisContainer: StartedTestContainer; let redisClient: RedisClientType; let cache: RedisCache; let service: ProductService; // Start Redis container before all tests beforeAll(async () => { redisContainer = await new GenericContainer('redis:7-alpine') .withExposedPorts(6379) .start(); const redisUrl = `redis://${redisContainer.getHost()}:${redisContainer.getMappedPort(6379)}`; redisClient = createClient({ url: redisUrl }); await redisClient.connect(); cache = new RedisCache(redisClient); service = new ProductService(cache, mockDatabase, mockMetrics); }, 60000); // Extended timeout for container startup afterAll(async () => { await redisClient.quit(); await redisContainer.stop(); }); beforeEach(async () => { // Clean slate for each test await redisClient.flushDb(); }); describe('Data Serialization', () => { it('should correctly serialize and deserialize complex objects', async () => { const complexProduct = { id: 'prod-1', name: 'Widget', price: 29.99, metadata: { tags: ['electronics', 'gadgets'], dimensions: { width: 10, height: 5, depth: 2 }, createdAt: new Date().toISOString(), }, variants: [ { sku: 'WID-RED', color: 'red', stock: 100 }, { sku: 'WID-BLU', color: 'blue', stock: 50 }, ], }; await cache.set('product:prod-1', complexProduct, 3600); const retrieved = await cache.get('product:prod-1'); expect(retrieved).toEqual(complexProduct); }); it('should handle special characters in data', async () => { const product = { id: 'prod-special', name: 'Widget™ — Pro Edition (Ü)', description: 'Features: "quotes", \backslash, emoji 🎉', }; await cache.set('product:prod-special', product, 3600); const retrieved = await cache.get('product:prod-special'); expect(retrieved?.name).toBe('Widget™ — Pro Edition (Ü)'); expect(retrieved?.description).toContain('🎉'); }); }); describe('TTL Behavior with Real Time', () => { it('should expire entries after TTL', async () => { const product = { id: 'prod-1', name: 'Short-lived Widget' }; // Set with 1 second TTL await cache.set('product:prod-1', product, 1); // Should exist immediately expect(await cache.get('product:prod-1')).not.toBeNull(); // Wait for expiration await new Promise(resolve => setTimeout(resolve, 1500)); // Should be expired expect(await cache.get('product:prod-1')).toBeNull(); }); }); describe('Concurrent Access', () => { it('should handle concurrent reads correctly', async () => { const product = { id: 'prod-1', name: 'Widget' }; await cache.set('product:prod-1', product, 3600); // Simulate 100 concurrent reads const reads = Array.from({ length: 100 }, () => cache.get('product:prod-1')); const results = await Promise.all(reads); // All reads should return the same data results.forEach(result => { expect(result).toEqual(product); }); }); it('should handle concurrent writes correctly', async () => { // Simulate concurrent writes with different values const writes = Array.from({ length: 100 }, (_, i) => cache.set(`product:prod-${i}`, { id: `prod-${i}`, name: `Widget ${i}` }, 3600) ); await Promise.all(writes); // Verify all writes succeeded for (let i = 0; i < 100; i++) { const result = await cache.get(`product:prod-${i}`); expect(result?.id).toBe(`prod-${i}`); } }); }); describe('Connection Resilience', () => { it('should handle connection interruption gracefully', async () => { // This test verifies error handling when Redis becomes unavailable const product = { id: 'prod-1', name: 'Widget' }; await cache.set('product:prod-1', product, 3600); // Pause the container to simulate network issues await redisContainer.exec(['redis-cli', 'DEBUG', 'SLEEP', '2']); // Attempt operation during "outage" - should throw or return null gracefully await expect(async () => { await Promise.race([ cache.get('product:prod-1'), new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 1000)) ]); }).rejects.toThrow(); // Wait for recovery await new Promise(resolve => setTimeout(resolve, 3000)); // Should work again const result = await cache.get('product:prod-1'); expect(result).toEqual(product); }); }); });80:Tf9f,import org.junit.jupiter.api.*; import org.testcontainers.containers.GenericContainer; import org.testcontainers.junit.jupiter.Container; import org.testcontainers.junit.jupiter.Testcontainers; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; @Testcontainers class ProductServiceRedisIntegrationTest { @Container private static final GenericContainer redisContainer = new GenericContainer<>("redis:7-alpine") .withExposedPorts(6379); private static JedisPool jedisPool; private RedisCache cache; private ProductService service; @BeforeAll static void setUpRedis() { String host = redisContainer.getHost(); Integer port = redisContainer.getMappedPort(6379); jedisPool = new JedisPool(host, port); } @AfterAll static void tearDownRedis() { jedisPool.close(); } @BeforeEach void setUp() { try (Jedis jedis = jedisPool.getResource()) { jedis.flushDB(); } cache = new RedisCache<>(jedisPool, Product.class); service = new ProductService(cache, mockDatabase, mockMetrics); } @Nested @DisplayName("Data Serialization") class DataSerialization { @Test @DisplayName("should correctly serialize and deserialize complex objects") void shouldSerializeComplexObjects() { Product complex = Product.builder() .id("prod-1") .name("Widget") .price(BigDecimal.valueOf(29.99)) .metadata(Map.of( "tags", List.of("electronics", "gadgets"), "dimensions", Map.of("width", 10, "height", 5) )) .variants(List.of( new Variant("WID-RED", "red", 100), new Variant("WID-BLU", "blue", 50) )) .build(); cache.set("product:prod-1", complex, Duration.ofHours(1)); Optional retrieved = cache.get("product:prod-1"); assertThat(retrieved).isPresent(); assertThat(retrieved.get()).isEqualTo(complex); assertThat(retrieved.get().getVariants()).hasSize(2); } } @Nested @DisplayName("TTL Behavior") class TtlBehavior { @Test @DisplayName("should expire entries after TTL") void shouldExpireAfterTtl() throws InterruptedException { Product product = new Product("prod-1", "Widget", BigDecimal.valueOf(29.99)); // Set with 1 second TTL cache.set("product:prod-1", product, Duration.ofSeconds(1)); // Should exist immediately assertThat(cache.get("product:prod-1")).isPresent(); // Wait for expiration Thread.sleep(1500); // Should be expired assertThat(cache.get("product:prod-1")).isEmpty(); } } @Nested @DisplayName("Concurrent Access") class ConcurrentAccess { @Test @DisplayName("should handle concurrent reads correctly") void shouldHandleConcurrentReads() throws Exception { Product product = new Product("prod-1", "Widget", BigDecimal.valueOf(29.99)); cache.set("product:prod-1", product, Duration.ofHours(1)); ExecutorService executor = Executors.newFixedThreadPool(10); List>> futures = new ArrayList<>(); for (int i = 0; i < 100; i++) { futures.add(executor.submit(() -> cache.get("product:prod-1"))); } for (Future> future : futures) { assertThat(future.get()).isPresent().contains(product); } executor.shutdown(); } } }81:T1875,describe('Cache Stampede Prevention', () => { let cache: InMemoryCache; let database: MockSlowDatabase; let service: StampedeProtectedProductService; beforeEach(() => { cache = new InMemoryCache(); database = new MockSlowDatabase(100); // 100ms latency per query service = new StampedeProtectedProductService(cache, database); }); describe('Request Coalescing', () => { it('should only hit database once for concurrent requests to same key', async () => { // Arrange: Empty cache const product = { id: 'prod-1', name: 'Widget', price: 29.99 }; database.setProduct('prod-1', product); // Act: Fire 10 concurrent requests for the same product const requests = Array.from({ length: 10 }, () => service.getProduct('prod-1') ); const results = await Promise.all(requests); // Assert: All requests get the same result results.forEach(result => expect(result).toEqual(product)); // Only ONE database query should have been made expect(database.queryCount).toBe(1); }); it('should not coalesce requests for different keys', async () => { // Arrange database.setProduct('prod-1', { id: 'prod-1', name: 'Widget 1' }); database.setProduct('prod-2', { id: 'prod-2', name: 'Widget 2' }); database.setProduct('prod-3', { id: 'prod-3', name: 'Widget 3' }); // Act: Concurrent requests for different products const requests = [ service.getProduct('prod-1'), service.getProduct('prod-2'), service.getProduct('prod-3'), ]; await Promise.all(requests); // Assert: Each product triggers its own query expect(database.queryCount).toBe(3); }); }); describe('Distributed Locking', () => { it('should acquire lock before regenerating cache', async () => { const lockManager = new MockLockManager(); const lockingService = new LockingCacheService(cache, database, lockManager); database.setProduct('prod-1', { id: 'prod-1', name: 'Widget' }); await lockingService.getProduct('prod-1'); // Verify lock was acquired and released expect(lockManager.acquisitions).toContainEqual({ key: 'cache-lock:product:prod-1', acquired: true, released: true }); }); it('should wait for existing lock instead of querying database', async () => { const lockManager = new MockLockManager(); const lockingService = new LockingCacheService(cache, database, lockManager); // Simulate another process holding the lock lockManager.holdLock('cache-lock:product:prod-1', 50); // 50ms // Simulate that while waiting, the cache gets populated setTimeout(async () => { await cache.set('product:prod-1', { id: 'prod-1', name: 'Widget' }, 3600); }, 30); const result = await lockingService.getProduct('prod-1'); expect(result.name).toBe('Widget'); // Database should NOT have been queried - got from cache after lock released expect(database.queryCount).toBe(0); }); }); describe('Probabilistic Early Expiration', () => { it('should sometimes refresh before actual expiration', async () => { const earlyExpirationService = new EarlyExpirationCacheService(cache, database, { beta: 1.0, // Higher beta = more likely to refresh early }); const product = { id: 'prod-1', name: 'Widget' }; database.setProduct('prod-1', product); // Populate cache with entry that will expire in 10 seconds // but has been there for 9 seconds already (delta = 1 second remaining) await cache.set('product:prod-1', { data: product, cachedAt: Date.now() - 9000, ttl: 10000 }, 10); // Run multiple fetches and count how many trigger refresh let refreshCount = 0; for (let i = 0; i < 100; i++) { database.queryCount = 0; await earlyExpirationService.getProduct('prod-1'); if (database.queryCount > 0) refreshCount++; } // With beta=1.0 and only 1 second remaining, should refresh frequently expect(refreshCount).toBeGreaterThan(20); expect(refreshCount).toBeLessThan(100); // But not every time }); }); }); // Implementation: Request coalescing class StampedeProtectedProductService { private inFlightRequests: Map> = new Map(); constructor( private cache: Cache, private database: ProductDatabase ) {} async getProduct(id: string): Promise { const cacheKey = `product:${id}`; // Check cache first const cached = await this.cache.get(cacheKey); if (cached) return cached; // Check for in-flight request const inFlight = this.inFlightRequests.get(cacheKey); if (inFlight) { return inFlight; // Piggyback on existing request } // Create new request and store it const request = this.fetchAndCache(id, cacheKey); this.inFlightRequests.set(cacheKey, request); try { return await request; } finally { this.inFlightRequests.delete(cacheKey); } } private async fetchAndCache(id: string, cacheKey: string): Promise { const product = await this.database.find(id); await this.cache.set(cacheKey, product, 3600); return product; } }72:{"json":{"id":"seed_d9b425fa2b75d2e9d3555a196c1f20a7","slug":"cache-testing-and-monitoring","category":"System Design (LLD)","topic":"Cache Testing and Monitoring","title":"Cache Testing and Monitoring","description":"Master the art of testing and monitoring cache implementations. Learn how to verify cache correctness, measure performance metrics, debug cache-related issues, and tune cache configurations for optimal system behavior.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_7b0ffc37ca8e80ed60db975fde28cd14","title":"Testing Cached Behavior","order":0,"content":[{"id":"opening-hook","title":"The Hidden Cost of Untested Caches","content":[{"data":{"content":"Caching is a double-edged sword. When implemented correctly, it transforms sluggish applications into responsive systems. When implemented incorrectly—or when correctness erodes over time—it introduces some of the most insidious bugs in software engineering: **stale data served to users**, **inconsistent state across services**, and **phantom performance that evaporates under changed conditions**.\n\nThe fundamental challenge is this: caching inherently adds a layer of indirection between what users request and what they receive. Without rigorous testing, you cannot guarantee that this layer behaves correctly under all circumstances—cache hits, cache misses, evictions, invalidations, concurrent access, and failure scenarios.\n\nThis page establishes a comprehensive framework for testing cached behavior at every level of your system, from unit tests that verify individual cache operations to integration tests that validate end-to-end caching semantics."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand how to design testable cache implementations, write unit tests that verify cache correctness, create integration tests that validate caching semantics, and apply test patterns that catch cache-related bugs before they reach production.","variant":"info"},"type":"callout"}]},{"id":"why-cache-testing-different","title":"Why Cache Testing is Different","content":[{"data":{"content":"Testing cache behavior differs fundamentally from testing regular business logic. Traditional tests verify that given input A, you receive output B. Cache tests must verify a more complex property: **regardless of cache state, the observable behavior must match the specification**.\n\nThis distinction creates unique testing challenges:"},"type":"text"},{"data":{"items":["**State-Dependent Behavior** — The same operation may produce different internal paths (cache hit vs. miss) while appearing identical externally. Tests must verify correctness in both scenarios.","**Time-Dependent Behavior** — Cache entries expire based on TTL configurations. Tests must handle time-based logic without relying on real-time waits that slow down test suites.","**Ordering Dependencies** — The sequence of cache operations affects subsequent behavior. A test that passes in isolation may fail when run after other tests that pollute cache state.","**Concurrency Concerns** — Multiple threads accessing the cache simultaneously can expose race conditions, cache stampedes, and consistency violations.","**Infrastructure Coupling** — Many caches depend on external systems (Redis, Memcached) that must be available during testing, complicating test environment setup."],"title":{"icon":"AlertCircle","text":"Unique Challenges in Cache Testing","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"content":"**The Correctness Contract:**\n\nA cache must satisfy two fundamental properties:\n\n1. **Transparency**: From the client's perspective, a cached system must behave identically to an uncached system (except for performance). If the underlying data source returns X, the cache must eventually return X.\n\n2. **Consistency**: The cache must not return data that contradicts the current state of the source-of-truth, within the bounds of the chosen consistency model (strong, eventual, or read-your-writes).\n\nEvery cache test should ultimately verify one or both of these properties. A test that only checks 'the cache returns something' without verifying correctness provides false confidence."},"type":"text"},{"data":{"icon":"AlertCircle","title":"The Silent Failure Mode","content":"Cache bugs rarely crash applications. Instead, they silently serve stale or incorrect data. Users see outdated prices, missing inventory, old profile pictures—and often don't report it because they assume the data is correct. Rigorous testing is your only defense against these silent failures.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"designing-for-testability","title":"Designing Cache Implementations for Testability","content":[{"data":{"content":"Before discussing test patterns, we must address a foundational truth: **poorly designed cache implementations are difficult or impossible to test properly**. Testability must be designed into the cache layer from the beginning.\n\nThe key principle is **separation of concerns through abstraction**. The cache mechanism should be decoupled from the business logic that uses it, allowing both to be tested independently and together."},"type":"text"},{"data":{"fileName":"Designing a Testable Cache Interface","languages":[{"code":"$7a","label":"TypeScript","value":"typescript"},{"code":"$7b","label":"Java","value":"java"}]},"type":"code"},{"data":{"icon":"Lightbulb","title":"Test Helpers in Cache Implementations","content":"Notice how the InMemoryCache includes test helper methods like 'expireEntry()' and 'hasEntry()'. These methods expose internal state for testing purposes. In production caches, you typically can't inspect or manipulate internal state—but in test caches, these capabilities are invaluable for verifying correct behavior.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"unit-testing-cache-operations","title":"Unit Testing Cache Operations","content":[{"data":{"content":"Unit tests for cache behavior should verify the fundamental operations in isolation. Each test should be independent, repeatable, and fast. The key categories of unit tests for caching are:\n\n**1. Cache Miss Behavior** — Verify that when data isn't cached, the system correctly fetches from the source and populates the cache.\n\n**2. Cache Hit Behavior** — Verify that when data is cached, the system returns it without accessing the source.\n\n**3. Cache Invalidation** — Verify that invalidation operations correctly remove or update cached data.\n\n**4. TTL Expiration** — Verify that expired entries are treated as cache misses."},"type":"text"},{"data":{"fileName":"Comprehensive Cache Unit Tests","languages":[{"code":"$7c","label":"TypeScript","value":"typescript"},{"code":"$7d","label":"Java","value":"java"}]},"type":"code"},{"data":{"icon":"Info","title":"Test Isolation is Critical","content":"Each test creates fresh cache, database, and metrics instances in beforeEach/setUp. This ensures test isolation—no test can affect another through shared cache state. Cache pollution is a common source of flaky tests in systems that share cache instances across tests.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"testing-cache-invalidation","title":"Testing Cache Invalidation","content":[{"data":{"content":"Cache invalidation is famously one of the two hard problems in computer science. Testing invalidation logic is equally challenging because you must verify both **what gets invalidated** and **what remains cached**.\n\nInvalidation tests should cover:\n\n- **Direct Invalidation** — When data is updated, the corresponding cache entry is removed\n- **Cascading Invalidation** — When parent data changes, related child entries are also invalidated\n- **Pattern-Based Invalidation** — When cache keys matching a pattern are invalidated\n- **Version-Based Invalidation** — When cache version changes cause old entries to be bypassed"},"type":"text"},{"data":{"fileName":"Testing Cache Invalidation Scenarios","languages":[{"code":"$7e","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"AlertCircle","title":"Invalidation Completeness","content":"One of the most common cache bugs is incomplete invalidation—updating a product but forgetting to invalidate the category listing that contains it. Tests should explicitly verify that ALL related caches are invalidated, not just the obvious ones.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"integration-testing-real-caches","title":"Integration Testing with Real Caches","content":[{"data":{"content":"While unit tests with in-memory cache implementations verify logic correctness, integration tests with real cache systems (Redis, Memcached) verify that your code handles the actual infrastructure correctly.\n\nIntegration tests catch issues that unit tests miss:\n\n- **Serialization/Deserialization** — Does your data survive the roundtrip through the cache's wire protocol?\n- **Connection Handling** — Does your code handle connection failures, timeouts, and reconnection?\n- **Concurrency Behavior** — Does the real cache behave correctly under concurrent access?\n- **Memory Limits** — What happens when the cache is full and evictions occur?"},"type":"text"},{"data":{"fileName":"Integration Tests with Testcontainers","languages":[{"code":"$7f","label":"TypeScript","value":"typescript"},{"code":"$80","label":"Java","value":"java"}]},"type":"code"},{"data":{"icon":"Lightbulb","title":"Testcontainers for Reproducible Integration Tests","content":"Testcontainers automatically manages Docker containers for your tests. Each test run gets a fresh Redis instance, ensuring tests are isolated and reproducible. The containers are automatically cleaned up after tests complete. This eliminates 'works on my machine' issues with integration tests.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"testing-cache-stampede-prevention","title":"Testing Cache Stampede Prevention","content":[{"data":{"content":"A **cache stampede** (also called cache thundering herd) occurs when a cache entry expires and multiple concurrent requests simultaneously attempt to regenerate it, overwhelming the backend. Testing stampede prevention mechanisms is crucial for systems under high load.\n\nStampede prevention techniques include:\n- **Locking** — Only one request regenerates the cache; others wait\n- **Probabilistic early expiration** — Randomly refresh before actual expiration\n- **Request coalescing** — Multiple requests share a single in-flight fetch"},"type":"text"},{"data":{"fileName":"Testing Cache Stampede Prevention","languages":[{"code":"$81","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"Info","title":"Measuring Stampede Prevention Effectiveness","content":"When testing stampede prevention, measure not just 'did it work' but 'how well did it work'. Track database query count, latency distribution across requests, and lock contention. A poorly implemented stampede prevention mechanism can actually increase latency for most requests while only slightly reducing database load.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"summary","title":"Summary: Testing Cached Behavior","content":[{"data":{"content":"Testing cached behavior requires a systematic approach that addresses the unique challenges of stateful, time-dependent, concurrent systems. Let's consolidate the key principles:"},"type":"text"},{"data":{"type":"ordered","items":["**Design for testability** — Abstract the cache behind an interface so you can swap in-memory implementations for testing.","**Test both hit and miss paths** — Cache logic has bifurcating behavior; test both branches explicitly.","**Verify invalidation completeness** — Tests should confirm that ALL related cache entries are invalidated, not just the obvious ones.","**Use Testcontainers for integration tests** — Real cache behavior differs from in-memory mocks; test against actual Redis/Memcached.","**Test stampede prevention** — Verify that concurrent cache misses don't overwhelm your backend.","**Track cache operations** — In-memory test caches should record operations for assertion verification.","**Ensure test isolation** — Each test should start with a clean cache state to prevent pollution."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's next:**\n\nWith a solid foundation in testing cache behavior, we'll explore **Cache Hit/Miss Metrics**—how to instrument your cache to measure its effectiveness and identify optimization opportunities."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand how to design testable cache implementations, write comprehensive unit and integration tests for cache behavior, and verify stampede prevention mechanisms. These testing practices ensure your caches behave correctly before reaching production.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":7}],"isLocked":false},{"id":"seed_cdf3f1b6cbc3449715c91b487cc60df7","title":"Cache Hit/Miss Metrics","order":1,"content":null,"isLocked":true},{"id":"seed_c8d0a53bc1778c1543769ccfc3b0fc74","title":"Debugging Cache Issues","order":2,"content":null,"isLocked":true},{"id":"seed_3e413ac73993cfa5ac1a8128ce7864fb","title":"Cache Performance Tuning","order":3,"content":null,"isLocked":true}]}}