Function TestGet_ConcurrentAccess

internal/policy/cache/cache_test.go:330–391

(t *testing.T)

}

func TestGet_ConcurrentAccess(t *testing.T) {
	ctx := context.Background()

	tests := []struct {
		name          string
		numGoroutines int
		numOperations int
		expectedTotal int
	}{
		{
			name:          "concurrent access with 10 goroutines",
			numGoroutines: 10,
			numOperations: 100,
			expectedTotal: 1000,
		},
		{
			name:          "concurrent access with 5 goroutines",
			numGoroutines: 5,
			numOperations: 50,
			expectedTotal: 250,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Create a fresh cache for each test
			testCache := NewPolicyCache(ctx)

			var wg sync.WaitGroup
			wg.Add(tt.numGoroutines)

			// Start concurrent goroutines
			for i := 0; i < tt.numGoroutines; i++ {
				go func(id int) {
					defer wg.Done()
					for j := 0; j < tt.numOperations; j++ {
						key := fmt.Sprintf("key_%d_%d", id, j)
						value := fmt.Sprintf("value_%d_%d", id, j)
						testCache.Set(key, value, nil)
					}
				}(i)
			}

			wg.Wait()

			// Verify all values were set correctly
			count := 0
			for i := 0; i < tt.numGoroutines; i++ {
				for j := 0; j < tt.numOperations; j++ {
					key := fmt.Sprintf("key_%d_%d", i, j)
					expectedValue := fmt.Sprintf("value_%d_%d", i, j)
					value, ok := testCache.Get(key)
					assert.True(t, ok, "Key %s should exist", key)
					assert.Equal(t, expectedValue, value, "Value for key %s should match", key)
					count++
				}
			}