ctx_reclaim_test.go

// ⚡️ Fiber is an Express inspired web framework written in Go with ☕️
// 🤖 GitHub Repository: https://github.com/gofiber/fiber
// 📌 API Documentation: https://docs.gofiber.io

package fiber

import (
	"sync/atomic"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"github.com/valyala/fasthttp"
)

// acquireReclaimTestCtx wires up a *DefaultCtx for reclaim tests without going
// through a full request lifecycle, so each test can drive ScheduleReclaim,
// signalReleased, and ReleaseCtx in isolation.
func acquireReclaimTestCtx(t *testing.T) (*App, *DefaultCtx) {
	t.Helper()
	app := New()
	raw := app.AcquireCtx(&fasthttp.RequestCtx{})
	dc, ok := raw.(*DefaultCtx)
	require.True(t, ok, "AcquireCtx must return *DefaultCtx in tests")
	return app, dc
}

// TestDefaultCtx_ScheduleReclaim_HappyPath covers the dominant timed-out flow:
// after ScheduleReclaim is armed and both signals fire (handlerDone closes and
// the request handler releases the context), the context is returned to the
// pool, observable as IsAbandoned flipping back to false.
func TestDefaultCtx_ScheduleReclaim_HappyPath(t *testing.T) {
	t.Parallel()
	app, c := acquireReclaimTestCtx(t)

	handlerDone := make(chan struct{})
	c.ScheduleReclaim(handlerDone, nil)
	require.True(t, c.IsAbandoned(), "ScheduleReclaim must Abandon the ctx internally")

	close(handlerDone)
	require.True(t, c.IsAbandoned(), "ctx must stay abandoned until ReleaseCtx fires")

	app.ReleaseCtx(c)
	require.Eventually(t, func() bool {
		return !c.IsAbandoned()
	}, time.Second, 5*time.Millisecond, "ctx must be reclaimed once both signals fire")
}

// TestDefaultCtx_ScheduleReclaim_ReleaseBeforeHandlerDone covers the reverse
// ordering: ReleaseCtx is called first, then handlerDone closes. The reclaim
// goroutine must still wait on handlerDone before pooling.
func TestDefaultCtx_ScheduleReclaim_ReleaseBeforeHandlerDone(t *testing.T) {
	t.Parallel()
	app, c := acquireReclaimTestCtx(t)

	handlerDone := make(chan struct{})
	c.ScheduleReclaim(handlerDone, nil)

	app.ReleaseCtx(c)
	require.True(t, c.IsAbandoned(), "ctx must stay abandoned until handlerDone closes")

	close(handlerDone)
	require.Eventually(t, func() bool {
		return !c.IsAbandoned()
	}, time.Second, 5*time.Millisecond, "ctx must be reclaimed after handlerDone closes")
}

// TestDefaultCtx_ScheduleReclaim_CancelInvoked verifies the cancel hook fires
// exactly once when the handler goroutine finishes.
func TestDefaultCtx_ScheduleReclaim_CancelInvoked(t *testing.T) {
	t.Parallel()
	app, c := acquireReclaimTestCtx(t)

	var calls atomic.Int32
	cancel := func() { calls.Add(1) }

	handlerDone := make(chan struct{})
	c.ScheduleReclaim(handlerDone, cancel)

	close(handlerDone)
	app.ReleaseCtx(c)

	require.Eventually(t, func() bool {
		return calls.Load() == 1 && !c.IsAbandoned()
	}, time.Second, 5*time.Millisecond, "cancel must fire once and ctx must be reclaimed")
}

// TestDefaultCtx_ScheduleReclaim_NilCancel exercises the cancel==nil branch.
func TestDefaultCtx_ScheduleReclaim_NilCancel(t *testing.T) {
	t.Parallel()
	app, c := acquireReclaimTestCtx(t)

	handlerDone := make(chan struct{})
	c.ScheduleReclaim(handlerDone, nil)

	close(handlerDone)
	app.ReleaseCtx(c)

	require.Eventually(t, func() bool {
		return !c.IsAbandoned()
	}, time.Second, 5*time.Millisecond, "nil cancel must not block reclamation")
}

// TestDefaultCtx_signalReleased_NoReclaim guards that calling signalReleased on
// a context that was never armed for reclamation is a safe no-op. This is the
// SSE-style path (Abandon without ScheduleReclaim) hit through ReleaseCtx.
func TestDefaultCtx_signalReleased_NoReclaim(t *testing.T) {
	t.Parallel()
	_, c := acquireReclaimTestCtx(t)
	require.NotPanics(t, func() { c.signalReleased() })
	require.NotPanics(t, func() { c.signalReleased() })
}

// TestDefaultCtx_signalReleased_Idempotent guards the sync.Once semantics: even
// if the request release path fires multiple times, the latch must close once.
func TestDefaultCtx_signalReleased_Idempotent(t *testing.T) {
	t.Parallel()
	app, c := acquireReclaimTestCtx(t)

	handlerDone := make(chan struct{})
	c.ScheduleReclaim(handlerDone, nil)

	require.NotPanics(t, func() {
		c.signalReleased()
		c.signalReleased()
		c.signalReleased()
	})

	close(handlerDone)
	require.Eventually(t, func() bool {
		return !c.IsAbandoned()
	}, time.Second, 5*time.Millisecond, "ctx must still be reclaimed exactly once")

	_ = app
}

// TestApp_releaseDefaultCtx_AbandonedSignalsReclaim exercises the internal
// releaseDefaultCtx path (called by defaultRequestHandler's defer) for an
// abandoned, reclaim-armed context. It mirrors what ReleaseCtx does for the
// public CustomCtx path and ensures both release entry points fire the latch.
func TestApp_releaseDefaultCtx_AbandonedSignalsReclaim(t *testing.T) {
	t.Parallel()
	app, c := acquireReclaimTestCtx(t)

	handlerDone := make(chan struct{})
	c.ScheduleReclaim(handlerDone, nil)

	app.releaseDefaultCtx(c)
	require.True(t, c.IsAbandoned(), "abandoned ctx must not be pooled by releaseDefaultCtx")

	close(handlerDone)
	require.Eventually(t, func() bool {
		return !c.IsAbandoned()
	}, time.Second, 5*time.Millisecond, "releaseDefaultCtx must wire signalReleased into the latch")
}

// TestApp_releaseDefaultCtx_NotAbandonedPools verifies the non-abandoned branch
// in releaseDefaultCtx still pools the ctx through the normal path.
func TestApp_releaseDefaultCtx_NotAbandonedPools(t *testing.T) {
	t.Parallel()
	app, c := acquireReclaimTestCtx(t)

	require.False(t, c.IsAbandoned())
	require.NotPanics(t, func() { app.releaseDefaultCtx(c) })
}