test(utilities): add tests for previously-uncovered helpers

internal/utilities/strings.go, context.go, and io.go held small pure-ish
helpers but had no test coverage. Add focused unit tests so behaviour
changes get caught: round-trip tests for StringValue and StringPtr; a
context-key formatting check plus set/read/replace/derive cases for
WithRequestID and GetRequestID; cancellation and completion cases for
WaitForCleanup; and behaviour assertions for SafeClose covering the
happy path, the error path, and io.NopCloser.

Coverage for the package goes from 50.8% to 62.4% with no behaviour
changes.

Signed-off-by: Manas Srivastava <mastermanas805@gmail.com>

Author: mastermanas805

internal/utilities/context_test.go

@@ -0,0 +1,84 @@
+package utilities
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestContextKeyString(t *testing.T) {
+	require.Equal(t, "gotrue api context key request_id", contextKey("request_id").String())
+	require.Equal(t, "gotrue api context key ", contextKey("").String())
+}
+
+func TestRequestIDRoundtrip(t *testing.T) {
+	t.Run("set then read", func(t *testing.T) {
+		ctx := WithRequestID(context.Background(), "abc-123")
+		require.Equal(t, "abc-123", GetRequestID(ctx))
+	})
+
+	t.Run("missing key returns empty string", func(t *testing.T) {
+		require.Equal(t, "", GetRequestID(context.Background()))
+	})
+
+	t.Run("set replaces previous value", func(t *testing.T) {
+		ctx := WithRequestID(context.Background(), "first")
+		ctx = WithRequestID(ctx, "second")
+		require.Equal(t, "second", GetRequestID(ctx))
+	})
+
+	t.Run("derived context inherits value", func(t *testing.T) {
+		ctx := WithRequestID(context.Background(), "parent-id")
+		child, cancel := context.WithCancel(ctx)
+		defer cancel()
+		require.Equal(t, "parent-id", GetRequestID(child))
+	})
+}
+
+func TestWaitForCleanup(t *testing.T) {
+	t.Run("returns when wait group is done", func(t *testing.T) {
+		var wg sync.WaitGroup
+		wg.Add(1)
+		go func() {
+			time.Sleep(10 * time.Millisecond)
+			wg.Done()
+		}()
+
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			WaitForCleanup(context.Background(), &wg)
+		}()
+
+		select {
+		case <-done:
+		case <-time.After(time.Second):
+			t.Fatal("WaitForCleanup did not return after wg.Done()")
+		}
+	})
+
+	t.Run("returns when context is cancelled before wait group is done", func(t *testing.T) {
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		ctx, cancel := context.WithCancel(context.Background())
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			WaitForCleanup(ctx, &wg)
+		}()
+
+		cancel()
+
+		select {
+		case <-done:
+		case <-time.After(time.Second):
+			t.Fatal("WaitForCleanup did not return after context cancellation")
+		}
+
+		wg.Done()
+	})
+}

internal/utilities/io_test.go

@@ -0,0 +1,34 @@
+package utilities
+
+import (
+	"errors"
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+type closerFunc func() error
+
+func (f closerFunc) Close() error { return f() }
+
+func TestSafeClose(t *testing.T) {
+	t.Run("calls Close on the underlying closer", func(t *testing.T) {
+		called := false
+		c := closerFunc(func() error {
+			called = true
+			return nil
+		})
+		SafeClose(c)
+		require.True(t, called, "Close should have been invoked")
+	})
+
+	t.Run("does not panic when Close returns an error", func(t *testing.T) {
+		c := closerFunc(func() error { return errors.New("close failed") })
+		require.NotPanics(t, func() { SafeClose(c) })
+	})
+
+	t.Run("does not panic for io.NopCloser", func(t *testing.T) {
+		require.NotPanics(t, func() { SafeClose(io.NopCloser(nil)) })
+	})
+}

internal/utilities/strings_test.go

@@ -0,0 +1,52 @@
+package utilities
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestStringValue(t *testing.T) {
+	t.Run("nil pointer returns empty string", func(t *testing.T) {
+		require.Equal(t, "", StringValue(nil))
+	})
+
+	t.Run("pointer to empty string returns empty string", func(t *testing.T) {
+		empty := ""
+		require.Equal(t, "", StringValue(&empty))
+	})
+
+	t.Run("pointer to non-empty string returns the value", func(t *testing.T) {
+		s := "hello"
+		require.Equal(t, "hello", StringValue(&s))
+	})
+}
+
+func TestStringPtr(t *testing.T) {
+	t.Run("empty string returns nil", func(t *testing.T) {
+		require.Nil(t, StringPtr(""))
+	})
+
+	t.Run("non-empty string returns a pointer to that value", func(t *testing.T) {
+		p := StringPtr("hello")
+		require.NotNil(t, p)
+		require.Equal(t, "hello", *p)
+	})
+
+	t.Run("returned pointer is independent of the input variable", func(t *testing.T) {
+		s := "original"
+		p := StringPtr(s)
+		require.Equal(t, "original", *p)
+		s = "mutated"
+		require.Equal(t, "original", *p)
+	})
+}
+
+func TestStringValueAndStringPtrRoundtrip(t *testing.T) {
+	cases := []string{"", "hello", "with spaces", "with\nnewline", "🦄"}
+	for _, c := range cases {
+		t.Run(c, func(t *testing.T) {
+			require.Equal(t, c, StringValue(StringPtr(c)))
+		})
+	}
+}