Method TestCacheClearWithoutCallback

internal/cache/timeoutCache_test.go:119–169

TestCacheClearWithoutCallback attempts to clear all entries from the cache and verifies that the associated callbacks are not invoked.

(t *testing.T)

// TestCacheClearWithoutCallback attempts to clear all entries from the cache
// and verifies that the associated callbacks are not invoked.
func (s) TestCacheClearWithoutCallback(t *testing.T) {
	var values []string
	const itemCount = 3
	for i := 0; i < itemCount; i++ {
		values = append(values, strconv.Itoa(i))
	}
	c := NewTimeoutCache(testCacheTimeout)

	done := make(chan struct{})
	defer close(done)
	callbackChan := make(chan struct{}, itemCount)

	for i, v := range values {
		callbackChanTemp := make(chan struct{})
		c.Add(i, v, func() { close(callbackChanTemp) })
		go func() {
			select {
			case <-callbackChanTemp:
				callbackChan <- struct{}{}
			case <-done:
			}
		}()
	}

	for i, v := range values {
		if got, ok := c.getForTesting(i); !ok || got.item != v {
			t.Fatalf("After Add(), before timeout, from cache got: %v, %v, want %v, %v", got.item, ok, v, true)
		}
	}
	if l := c.Len(); l != itemCount {
		t.Fatalf("%d number of items in the cache, want %d", l, itemCount)
	}

	time.Sleep(testCacheTimeout / 2)
	c.Clear(false)

	for i := range values {
		if _, ok := c.getForTesting(i); ok {
			t.Fatalf("After Add(), before timeout, after Remove(), from cache got: _, %v, want _, %v", ok, false)
		}
	}
	if l := c.Len(); l != 0 {
		t.Fatalf("%d number of items in the cache, want 0", l)
	}

	select {
	case <-callbackChan:
		t.Fatalf("unexpected callback after Clear")
	case <-time.After(testCacheTimeout * 2):
	}
}

// TestCacheClearWithCallback attempts to clear all entries from the cache and
// verifies that the associated callbacks are invoked.