Function TestDo

internal/cleanup/context_test.go:27–91

(t *testing.T)

)

func TestDo(t *testing.T) {
	t.Parallel()

	ctx, cancel := context.WithCancel(context.Background())
	var k struct{}
	v := "incontext"
	ctx = context.WithValue(ctx, k, v) //nolint:staticcheck

	assert.Nil(t, contextError(ctx))
	assert.Equal(t, ctx.Value(k), v)

	cancel()
	assert.Error(t, contextError(ctx))
	assert.Equal(t, ctx.Value(k), v)

	t.Run("with canceled context", func(t *testing.T) {
		t.Parallel()
		Do(ctx, func(ctx context.Context) {
			assert.NoError(t, contextError(ctx))
			assert.Equal(t, ctx.Value(k), v)
		})
	})

	t.Run("wrap with cancel", func(t *testing.T) {
		t.Parallel()
		Do(ctx, func(ctx context.Context) {
			ctx, cancelFn := context.WithCancel(ctx)
			cancelFn()
			assert.ErrorIs(t, contextError(ctx), context.Canceled)
			assert.Equal(t, ctx.Value(k), v)
		})
	})

	// canceled after 10 seconds
	t.Run("timeout", func(t *testing.T) {
		t.Parallel()

		done := make(chan struct{})
		called := make(chan struct{})

		Do(context.Background(), func(ctx context.Context) {
			close(called)
			select {
			case <-ctx.Done():
				close(done)
			case <-time.After(11 * time.Second):
				t.Error("context was not canceled in time")
			}
		})

		select {
		case <-done:
			// success
		case <-time.After(1 * time.Second):
			t.Error("timeout waiting for context cancellation")
		}

		select {