Function TestThrottlingWithoutStaleCache

registry/cache/cache_test.go:302–349

TestThrottlingWithoutStaleCache verifies that the cache throttles requests when there's no stale cache and the registry is failing

(t *testing.T)

// TestThrottlingWithoutStaleCache verifies that the cache throttles requests
// when there's no stale cache and the registry is failing
func TestThrottlingWithoutStaleCache(t *testing.T) {
	mock := &mockRegistry{
		err: errors.New("etcd connection failed"),
	}

	// Create cache with short retry interval for testing
	c := New(mock, func(o *Options) {
		o.TTL = time.Minute
		o.MinimumRetryInterval = 2 * time.Second
		o.Logger = logger.DefaultLogger
	}).(*cache)

	// First request - should fail and record the attempt
	_, err := c.GetService("test.service")
	if err == nil {
		t.Fatal("Expected error on first request, got nil")
	}

	callCount1 := mock.getCallCount()
	if callCount1 != 1 {
		t.Fatalf("Expected 1 call on first attempt, got %d", callCount1)
	}

	// Immediate second request - should be throttled (no registry call)
	_, err = c.GetService("test.service")
	if err == nil {
		t.Fatal("Expected error on throttled request, got nil")
	}

	callCount2 := mock.getCallCount()
	if callCount2 != 1 {
		t.Errorf("Expected throttling (still 1 call), got %d calls", callCount2)
	}

	// Wait for retry interval to pass
	time.Sleep(2100 * time.Millisecond)

	// Third request - should be allowed (makes another registry call)
	_, err = c.GetService("test.service")
	if err == nil {
		t.Fatal("Expected error after retry interval, got nil")
	}

	callCount3 := mock.getCallCount()
	if callCount3 != 2 {
		t.Errorf("Expected 2 calls after retry interval, got %d", callCount3)
	}
}

// TestThrottlingMultipleConcurrentRequests verifies that throttling works
// correctly with multiple concurrent requests when there's no stale cache