chore: add 100% test coverage to apitask package (#2146)

Quick PR to button up the apitask package.

Co-authored-by: Chris Stockton <[email protected]>

Author: cstockton

internal/api/apitask/apitask.go

@@ -1,3 +1,5 @@
+// Package apitask provides a background execution context for background work
+// that limits the execution time to the current request.
 package apitask
 
 import (

internal/api/apitask/apitask_test.go

@@ -2,6 +2,9 @@ package apitask
 
 import (
 	"context"
+	"errors"
+	"fmt"
+	"net/http"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -22,31 +25,34 @@ func taskFn(typ string, fn func(context.Context) error) Task {
 	return &taskFunc{typ: typ, fn: fn}
 }
 
-func TestRequestWorker(t *testing.T) {
+func TestContext(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
 	defer cancel()
 
-	t.Run("RunTasks", func(t *testing.T) {
-		{
-			rw, ok := from(ctx)
-			require.False(t, ok, "request worker must not found in context")
-			require.Nil(t, rw, "request worker must be nil")
-		}
+	{
+		rw, ok := from(ctx)
+		require.False(t, ok, "request worker must not found in context")
+		require.Nil(t, rw, "request worker must be nil")
+	}
 
-		withCtx := With(ctx)
-		{
-			rw, ok := from(withCtx)
-			require.True(t, ok, "request worker not found in context")
-			require.NotNil(t, rw, "request worker was nil")
-
-			withCtxDupe := With(withCtx)
-			sameRw, ok := from(withCtxDupe)
-			require.True(t, ok, "request worker not found in context")
-			require.True(t, rw == sameRw, "request worker should be created only once")
-		}
-	})
+	withCtx := With(ctx)
+	{
+		rw, ok := from(withCtx)
+		require.True(t, ok, "request worker not found in context")
+		require.NotNil(t, rw, "request worker was nil")
+
+		withCtxDupe := With(withCtx)
+		sameRw, ok := from(withCtxDupe)
+		require.True(t, ok, "request worker not found in context")
+		require.True(t, rw == sameRw, "request worker should be created only once")
+	}
+}
 
-	t.Run("RunTasks", func(t *testing.T) {
+func TestRun(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
+	defer cancel()
+
+	t.Run("Success", func(t *testing.T) {
 		withCtx := With(ctx)
 
 		calls := new(atomic.Int64)
@@ -68,4 +74,121 @@ func TestRequestWorker(t *testing.T) {
 			require.Equal(t, expCalls, gotCalls)
 		}
 	})
+	t.Run("Failure", func(t *testing.T) {
+
+		// exp no errors when async
+		t.Run("WhenAsync", func(t *testing.T) {
+			withCtx := With(ctx)
+
+			calls := new(atomic.Int64)
+			expCalls := 0
+			sentinel := errors.New("sentinel")
+			for range 16 {
+				expCalls++
+				task := taskFn("test.run", func(ctx context.Context) error {
+					calls.Add(1)
+					return sentinel
+				})
+				err := Run(withCtx, task)
+				require.NoError(t, err)
+			}
+
+			{
+				Wait(withCtx)
+
+				gotCalls := int(calls.Load())
+				require.Equal(t, expCalls, gotCalls)
+			}
+		})
+
+		// exp errors when sync
+		t.Run("WhenSync", func(t *testing.T) {
+			withCtx := ctx
+
+			calls := new(atomic.Int64)
+			expCalls := 0
+			sentinel := errors.New("sentinel")
+			for range 16 {
+				expCalls++
+				task := taskFn("test.run", func(ctx context.Context) error {
+					calls.Add(1)
+					return sentinel
+				})
+				err := Run(withCtx, task)
+				require.Error(t, err)
+			}
+
+			{
+				Wait(withCtx)
+
+				gotCalls := int(calls.Load())
+				require.Equal(t, expCalls, gotCalls)
+			}
+		})
+	})
+}
+
+func TestMiddleware(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+
+	t.Run("Success", func(t *testing.T) {
+		var errs []error
+		hrFunc := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			for i := range 10 {
+				typ := fmt.Sprintf("test-task-%v", i)
+				task := taskFn(typ, func(ctx context.Context) error {
+					return nil
+				})
+
+				err := Run(r.Context(), task)
+				errs = append(errs, err)
+			}
+		})
+		hr := Middleware(hrFunc)
+
+		req, err := http.NewRequestWithContext(ctx, "GET", "/", nil)
+		require.NoError(t, err)
+
+		for i := range 10 {
+			hr.ServeHTTP(nil, req)
+			require.Equal(t, 10*(i+1), len(errs))
+		}
+		for _, e := range errs {
+			require.NoError(t, e)
+		}
+	})
+
+	t.Run("Failure", func(t *testing.T) {
+		var errs []error
+		hrFunc := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			for i := range 10 {
+				typ := fmt.Sprintf("test-task-%v", i)
+				task := taskFn(typ, func(ctx context.Context) error {
+					return nil
+				})
+				err := Run(r.Context(), task)
+				errs = append(errs, err)
+			}
+		})
+		hr := Middleware(hrFunc)
+
+		ctx = With(ctx)
+		req, err := http.NewRequestWithContext(ctx, "GET", "/", nil)
+		require.NoError(t, err)
+
+		hr.ServeHTTP(nil, req)
+		require.Equal(t, 10, len(errs))
+
+		for _, e := range errs {
+			require.NoError(t, e)
+		}
+
+		errs = nil
+		hr.ServeHTTP(nil, req)
+		require.Equal(t, 10, len(errs))
+		for _, e := range errs {
+			require.Error(t, e)
+		}
+	})
 }

internal/api/options_test.go

@@ -4,7 +4,10 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/supabase/auth/internal/conf"
+	"github.com/supabase/auth/internal/e2e"
+	"github.com/supabase/auth/internal/mailer"
 )
 
 func TestNewLimiterOptions(t *testing.T) {
@@ -28,3 +31,17 @@ func TestNewLimiterOptions(t *testing.T) {
 	assert.NotNil(t, rl.SSO)
 	assert.NotNil(t, rl.SAMLAssertion)
 }
+
+func TestMailerOptions(t *testing.T) {
+	globalCfg := e2e.Must(e2e.Config())
+	conn := e2e.Must(e2e.Conn(globalCfg))
+
+	sentinelMailer := mailer.NewMailClient(globalCfg)
+	mailerOpts := &MailerOptions{MailerClientFunc: func() mailer.MailClient {
+		return sentinelMailer
+	}}
+	a := NewAPIWithVersion(globalCfg, conn, apiTestVersion, mailerOpts)
+
+	got := a.mailerClientFunc()
+	require.Equal(t, sentinelMailer, got)
+}