chore: test for core::execFunc() covering case with errCh drain

Signed-off-by: Artur Melanchyk <13834276+arturmelanchyk@users.noreply.github.com>

Author: arturmelanchyk

client/core_test.go

@@ -2,13 +2,16 @@ package client
 
 import (
 	"context"
+	"crypto/tls"
 	"errors"
 	"net"
+	"sync"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/valyala/fasthttp"
 	"github.com/valyala/fasthttp/fasthttputil"
 
 	"github.com/gofiber/fiber/v3"
@@ -154,6 +157,59 @@ func Test_Exec_Func(t *testing.T) {
 
 		require.Equal(t, ErrTimeoutOrCancel, err)
 	})
+
+	t.Run("cancel drains errChan", func(t *testing.T) {
+		core, client, req := newCore(), New(), AcquireRequest()
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		core.ctx = ctx
+		core.client = client
+		core.req = req
+
+		req.RawRequest.SetRequestURI("http://example.com/drain-err")
+
+		blockingTransport := newBlockingErrTransport(errors.New("upstream failure"))
+		client.transport = blockingTransport
+		defer blockingTransport.release()
+
+		type execResult struct {
+			resp *Response
+			err  error
+		}
+
+		resultCh := make(chan execResult, 1)
+		go func() {
+			resp, err := core.execFunc()
+			resultCh <- execResult{resp: resp, err: err}
+		}()
+
+		select {
+		case <-blockingTransport.called:
+		case <-time.After(time.Second):
+			t.Fatal("transport Do was not invoked")
+		}
+
+		cancel()
+
+		var result execResult
+		select {
+		case result = <-resultCh:
+		case <-time.After(time.Second):
+			t.Fatal("execFunc did not return")
+		}
+
+		require.Nil(t, result.resp)
+		require.ErrorIs(t, result.err, ErrTimeoutOrCancel)
+
+		blockingTransport.release()
+
+		select {
+		case <-blockingTransport.finished:
+		case <-time.After(time.Second):
+			t.Fatal("transport Do did not finish")
+		}
+	})
 }
 
 func Test_Execute(t *testing.T) {
@@ -269,3 +325,57 @@ func Test_Execute(t *testing.T) {
 		require.Equal(t, "example.com hang up", string(resp.RawResponse.Body()))
 	})
 }
+
+type blockingErrTransport struct {
+	err error
+
+	called   chan struct{}
+	unblock  chan struct{}
+	finished chan struct{}
+
+	calledOnce   sync.Once
+	releaseOnce  sync.Once
+	finishedOnce sync.Once
+}
+
+func newBlockingErrTransport(err error) *blockingErrTransport {
+	return &blockingErrTransport{
+		err:      err,
+		called:   make(chan struct{}),
+		unblock:  make(chan struct{}),
+		finished: make(chan struct{}),
+	}
+}
+
+func (b *blockingErrTransport) Do(req *fasthttp.Request, resp *fasthttp.Response) error {
+	b.calledOnce.Do(func() { close(b.called) })
+	<-b.unblock
+	b.finishedOnce.Do(func() { close(b.finished) })
+	return b.err
+}
+
+func (b *blockingErrTransport) DoTimeout(req *fasthttp.Request, resp *fasthttp.Response, timeout time.Duration) error {
+	return b.Do(req, resp)
+}
+
+func (b *blockingErrTransport) DoDeadline(req *fasthttp.Request, resp *fasthttp.Response, deadline time.Time) error {
+	return b.Do(req, resp)
+}
+
+func (b *blockingErrTransport) DoRedirects(req *fasthttp.Request, resp *fasthttp.Response, maxRedirects int) error {
+	return b.Do(req, resp)
+}
+
+func (b *blockingErrTransport) CloseIdleConnections() {}
+
+func (b *blockingErrTransport) TLSConfig() *tls.Config { return nil }
+
+func (b *blockingErrTransport) SetTLSConfig(_ *tls.Config) {}
+
+func (b *blockingErrTransport) SetDial(_ fasthttp.DialFunc) {}
+
+func (b *blockingErrTransport) Client() any { return nil }
+
+func (b *blockingErrTransport) release() {
+	b.releaseOnce.Do(func() { close(b.unblock) })
+}