Function testCacheConcurrentAccess

test/integration/cache_integration_test.go:322–399

testCacheConcurrentAccess tests concurrent cache operations.

(t *testing.T, c interfaces.Cache)

// testCacheConcurrentAccess tests concurrent cache operations.
func testCacheConcurrentAccess(t *testing.T, c interfaces.Cache) {
	t.Run("concurrent_set_get", func(t *testing.T) {
		const numGoroutines = 10

		const numOperations = 20

		results := make(chan error, numGoroutines*numOperations*2) // *2 for set and get

		// Launch concurrent goroutines
		for i := 0; i < numGoroutines; i++ {
			go func(goroutineID int) {
				for j := 0; j < numOperations; j++ {
					key := fmt.Sprintf("concurrent-%d-%d", goroutineID, j)
					value := fmt.Sprintf("value-%d-%d", goroutineID, j)

					// Set operation
					err := c.Set(key, value, time.Hour)
					results <- err

					// Get operation
					var result string
					_, err = c.Get(key, &result)
					results <- err
				}
			}(i)
		}

		// Collect results
		var errors []error

		for i := 0; i < numGoroutines*numOperations*2; i++ {
			if err := <-results; err != nil {
				errors = append(errors, err)
			}
		}

		// All operations should succeed
		assert.Empty(t, errors, "Expected no errors from concurrent operations")
	})

	t.Run("concurrent_delete_clear", func(t *testing.T) {
		// Pre-populate cache
		for i := 0; i < 100; i++ {
			key := fmt.Sprintf("delete-test-%d", i)
			err := c.Set(key, fmt.Sprintf("value-%d", i), time.Hour)
			require.NoError(t, err)
		}

		const numGoroutines = 5
		results := make(chan error, numGoroutines)

		// Launch concurrent delete operations
		for i := 0; i < numGoroutines; i++ {
			go func(goroutineID int) {
				if goroutineID == 0 {
					// One goroutine clears the cache
					results <- c.Clear()
				} else {