Function TestCachePenetrationPrevention

registry/cache/cache_test.go:228–298

TestCachePenetrationPrevention verifies the complete flow: 1. Cache populated 2. Cache expires 3. Registry fails 4. Concurrent requests don't stampede registry due to rate limiting 5. Stale cache is returned without hitting registry

(t *testing.T)

// 4. Concurrent requests don't stampede registry due to rate limiting
// 5. Stale cache is returned without hitting registry
func TestCachePenetrationPrevention(t *testing.T) {
	mock := &mockRegistry{
		services: []*registry.Service{
			{
				Name:    "test.service",
				Version: "1.0.0",
				Nodes: []*registry.Node{
					{Id: "node1", Address: "localhost:9090"},
				},
			},
		},
	}

	// Type assertion to *cache is necessary to access internal state for verification
	c := New(mock, func(o *Options) {
		o.TTL = 100 * time.Millisecond
		o.Logger = logger.DefaultLogger
		// Use short retry interval to test rate limiting
		o.MinimumRetryInterval = 5 * time.Second
	}).(*cache)

	// Initial request to populate cache
	_, err := c.GetService("test.service")
	if err != nil {
		t.Fatalf("Initial request failed: %v", err)
	}

	initialCalls := mock.getCallCount()
	if initialCalls != 1 {
		t.Fatalf("Expected 1 initial call, got %d", initialCalls)
	}

	// Wait for cache to expire (but not past retry interval)
	time.Sleep(150 * time.Millisecond)

	// Configure mock to fail with delay
	mock.err = errors.New("etcd overloaded")
	mock.delay = 100 * time.Millisecond

	// Launch many concurrent requests (simulating stampede)
	const concurrency = 50
	var wg sync.WaitGroup
	wg.Add(concurrency)

	successCount := int32(0)

	for i := 0; i < concurrency; i++ {
		go func() {
			defer wg.Done()
			services, err := c.GetService("test.service")
			// Should return stale cache without error (rate limiting prevents registry call)
			if err == nil && len(services) > 0 {
				atomic.AddInt32(&successCount, 1)
			}
		}()
	}

	wg.Wait()