coder
diff --git a/‎coderd/files/cache_internal_test.go
Lines changed: 41 additions & 4 deletions b/‎coderd/files/cache_internal_test.go
Lines changed: 41 additions & 4 deletions
@@ -10,19 +10,20 @@ import (
 
 	"github.com/coder/coder/v2/testutil"
 	"github.com/google/uuid"
-	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/sync/errgroup"
 )
 
-func TestTryAgain(t *testing.T) {
+func TestConcurrency(t *testing.T) {
+	t.Parallel()
+
 	var fetches atomic.Int64
 	c := newTestCache(func(_ context.Context, _ uuid.UUID) (fs.FS, error) {
 		fetches.Add(1)
 		// Wait long enough before returning to make sure that all of the goroutines
 		// will be waiting in line, ensuring that no one duplicated a fetch.
 		time.Sleep(testutil.IntervalMedium)
-		return afero.NewIOFS(afero.NewMemMapFs()), nil
+		return nil, nil
 	})
 
 	batches := 1000
@@ -32,7 +33,8 @@ func TestTryAgain(t *testing.T) {
 	}
 
 	// Call Acquire with a unique ID per batch, many times per batch, with many
-	// batches all in parallel. This gives us
+	// batches all in parallel. This is pretty much the worst-case scenario:
+	// thousands of concurrent reads, with both warm and cold loads happening.
 	batchSize := 10
 	for _, g := range groups {
 		id := uuid.New()
@@ -50,6 +52,41 @@ func TestTryAgain(t *testing.T) {
 	require.Equal(t, int64(batches), fetches.Load())
 }
 
+func TestRelease(t *testing.T) {
+	t.Parallel()
+
+	c := newTestCache(func(_ context.Context, _ uuid.UUID) (fs.FS, error) {
+		return nil, nil
+	})
+
+	batches := 100
+	ids := make([]uuid.UUID, 0, batches)
+	for range batches {
+		ids = append(ids, uuid.New())
+	}
+
+	// Acquire a bunch of references
+	batchSize := 10
+	for _, id := range ids {
+		for range batchSize {
+			c.Acquire(t.Context(), id)
+		}
+	}
+
+	// Make sure cache is fully loaded
+	require.Equal(t, len(c.data), batches)
+
+	// Now release all of the references
+	for _, id := range ids {
+		for range batchSize {
+			c.Release(id)
+		}
+	}
+
+	// ...and make sure that the cache has emptied itself.
+	require.Equal(t, len(c.data), 0)
+}
+
 func newTestCache(fetcher func(context.Context, uuid.UUID) (fs.FS, error)) Cache {
 	return Cache{
 		lock:    sync.Mutex{},