Function TestDoBatchWithOptionsContextCancellation

ring/ring_test.go:211–342

(t *testing.T)

}

func TestDoBatchWithOptionsContextCancellation(t *testing.T) {
	const (
		numKeys      = 5e6
		numInstances = 100
		numZones     = 3
	)
	cancelCause := errors.New("cancel cause")

	measureDuration := func(r *Ring, keys []uint32) time.Duration {
		callback := func(InstanceDesc, []int) error { return nil }
		t0 := time.Now()
		err := DoBatchWithOptions(context.Background(), Write, r, keys, callback, DoBatchOptions{})
		duration := time.Since(t0)
		require.NoError(t, err)
		t.Logf("Call took %s", duration)
		return duration
	}

	type callbackFunc = func(InstanceDesc, []int) error
	never := func(_ InstanceDesc, _ []int) error {
		t.Errorf("should not be called.")
		return nil
	}
	tests := []struct {
		name        string
		setup       func(*Ring, []uint32) (context.Context, callbackFunc)
		expectedErr error
	}{
		{
			name: "context deadline exceeded",
			setup: func(r *Ring, keys []uint32) (context.Context, callbackFunc) {
				duration := measureDuration(r, keys)

				// Make a second call cancelling after a hundredth of duration of the first one.
				// For a 4s first call, this is 40ms: should be enough for this test to not be flaky.
				ctx, cancel := context.WithTimeout(context.Background(), duration/100)
				go func() {
					<-ctx.Done()
					cancel()
				}()
				return ctx, never
			},
			expectedErr: context.DeadlineExceeded,
		},
		{
			name: "context deadline exceeded with cause",
			setup: func(r *Ring, keys []uint32) (context.Context, callbackFunc) {
				duration := measureDuration(r, keys)

				// Make a second call cancelling after a hundredth of duration of the first one.
				// For a 4s first call, this is 40ms: should be enough for this test to not be flaky.
				ctx, cancel := context.WithTimeoutCause(context.Background(), duration/100, cancelCause)
				go func() {
					<-ctx.Done()
					cancel()
				}()
				return ctx, never
			},