package cachetype import ( "reflect" "time" "github.com/hashicorp/consul/agent/cache" "github.com/mitchellh/go-testing-interface" ) // TestRPC returns a mock implementation of the RPC interface. func TestRPC(t testing.T) *MockRPC { // This function is relatively useless but this allows us to perhaps // perform some initialization later. return &MockRPC{} } // TestFetchCh returns a channel that returns the result of the Fetch call. // This is useful for testing timing and concurrency with Fetch calls. // Errors will show up as an error type on the resulting channel so a // type switch should be used. func TestFetchCh( t testing.T, typ cache.Type, opts cache.FetchOptions, req cache.Request) <-chan interface{} { resultCh := make(chan interface{}) go func() { result, err := typ.Fetch(opts, req) if err != nil { resultCh <- err return } resultCh <- result }() return resultCh } // TestFetchChResult tests that the result from TestFetchCh matches // within a reasonable period of time (it expects it to be "immediate" but // waits some milliseconds). func TestFetchChResult(t testing.T, ch <-chan interface{}, expected interface{}) { t.Helper() select { case result := <-ch: if err, ok := result.(error); ok { t.Fatalf("Result was error: %s", err) return } if !reflect.DeepEqual(result, expected) { t.Fatalf("Result doesn't match!\n\n%#v\n\n%#v", result, expected) } case <-time.After(50 * time.Millisecond): } }