feat: add support packages for end-to-end testing (#2021)

Added 3 new packages in the "e2e" directory to make writing tests that
needed an API server, hook server or both easier. Also added some simple
helpers for config and connection loading from within unit tests.

The packages:
- Package e2e provides a few utilities for use in unit tests.
- Package e2eapi provides utilities for end-to-end testing the api.
- Package e2ehooks provides utilities for end-to-end testing of hooks.
-

---------

Co-authored-by: Chris Stockton <chris.stockton@supabase.io>

Author: cstockton

internal/e2e/e2e.go

@@ -0,0 +1,67 @@
+// Package e2e provides a few utilities for use in unit tests.
+package e2e
+
+import (
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/supabase/auth/internal/conf"
+	"github.com/supabase/auth/internal/storage"
+	"github.com/supabase/auth/internal/storage/test"
+)
+
+var (
+	projectRoot string
+	configPath  string
+)
+
+func init() {
+	if testing.Testing() {
+		_, thisFile, _, _ := runtime.Caller(0)
+		projectRoot = filepath.Join(filepath.Dir(thisFile), "../..")
+		configPath = filepath.Join(GetProjectRoot(), "hack", "test.env")
+	} else {
+		panic("package e2e may not be used in a main package")
+	}
+}
+
+// GetProjectRoot returns the path to the root of the project. This may be used
+// to locate files without needing the relative path from a given test.
+func GetProjectRoot() string {
+	return projectRoot
+}
+
+// GetConfigPath returns the path for the "/hack/test.env" config file.
+func GetConfigPath() string {
+	return configPath
+}
+
+// Config calls conf.LoadGlobal using GetConfigPath().
+func Config() (*conf.GlobalConfiguration, error) {
+	globalCfg, err := conf.LoadGlobal(GetConfigPath())
+	if err != nil {
+		return nil, err
+	}
+	return globalCfg, nil
+}
+
+// Conn returns a connection for the given config.
+func Conn(globalCfg *conf.GlobalConfiguration) (*storage.Connection, error) {
+	conn, err := test.SetupDBConnection(globalCfg)
+	if err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+// Must may be used by Config and Conn, i.e.:
+//
+//	cfg := e2e.Must(e2e.Config())
+//	conn := e2e.Must(e2e.Conn(cfg))
+func Must[T any](res T, err error) T {
+	if err != nil {
+		panic(err)
+	}
+	return res
+}

internal/e2e/e2e_test.go

@@ -0,0 +1,97 @@
+package e2e
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/supabase/auth/internal/conf"
+)
+
+func TestUtils(t *testing.T) {
+
+	// check paths
+	require.Equal(t, projectRoot, GetProjectRoot())
+	require.Equal(t, configPath, GetConfigPath())
+
+	// Config
+	func() {
+
+		// positive
+		{
+			testCfgPath := "../../hack/test.env"
+			testCfg := Must(conf.LoadGlobal(testCfgPath))
+			globalCfg := Must(Config())
+			require.Equal(t, testCfg, globalCfg)
+		}
+
+		// negative
+		{
+			restore := configPath
+			defer func() {
+				configPath = restore
+			}()
+			configPath = "abc"
+
+			globalCfg, err := Config()
+			if err == nil {
+				t.Fatal("exp non-nil err")
+			}
+			if globalCfg != nil {
+				t.Fatal("exp nil conn")
+			}
+		}
+	}()
+
+	// Conn
+	func() {
+		// positive
+		{
+			globalCfg := Must(Config())
+			conn := Must(Conn(globalCfg))
+			if conn == nil {
+				t.Fatal("exp non-nil conn")
+			}
+		}
+
+		// negative
+		{
+			globalCfg := Must(Config())
+			globalCfg.DB.Driver = ""
+			globalCfg.DB.URL = "invalid"
+			conn, err := Conn(globalCfg)
+			if err == nil {
+				t.Fatal("exp non-nil err")
+			}
+			if conn != nil {
+				t.Fatal("exp nil conn")
+			}
+		}
+
+	}()
+
+	// Must
+	func() {
+		restore := configPath
+		defer func() {
+			configPath = restore
+		}()
+		configPath = "abc"
+
+		var err error
+		func() {
+			defer func() {
+				err = recover().(error)
+			}()
+
+			globalCfg := Must(Config())
+			if globalCfg != nil {
+				panic(errors.New("globalCfg != nil"))
+			}
+		}()
+
+		if err == nil {
+			t.Fatal("exp non-nil err")
+		}
+	}()
+}

internal/e2e/e2eapi/e2eapi.go

@@ -0,0 +1,151 @@
+// Package e2eapi provides utilities for end-to-end testing the api.
+package e2eapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/supabase/auth/internal/api"
+	"github.com/supabase/auth/internal/api/apierrors"
+	"github.com/supabase/auth/internal/conf"
+	"github.com/supabase/auth/internal/storage"
+	"github.com/supabase/auth/internal/storage/test"
+	"github.com/supabase/auth/internal/utilities"
+)
+
+type Instance struct {
+	Config    *conf.GlobalConfiguration
+	Conn      *storage.Connection
+	APIServer *httptest.Server
+
+	closers []func()
+}
+
+func New(globalCfg *conf.GlobalConfiguration) (*Instance, error) {
+	o := new(Instance)
+	o.Config = globalCfg
+
+	conn, err := test.SetupDBConnection(globalCfg)
+	if err != nil {
+		return nil, fmt.Errorf("error setting up db connection: %w", err)
+	}
+	o.addCloser(func() {
+		if conn.Store != nil {
+			_ = conn.Close()
+		}
+	})
+	o.Conn = conn
+
+	apiVer := utilities.Version
+	if apiVer == "" {
+		apiVer = "1"
+	}
+
+	a := api.NewAPIWithVersion(globalCfg, conn, apiVer)
+	apiSrv := httptest.NewServer(a)
+	o.addCloser(apiSrv)
+	o.APIServer = apiSrv
+
+	return o, nil
+}
+
+func (o *Instance) Close() error {
+	for _, fn := range o.closers {
+		defer fn()
+	}
+	return nil
+}
+
+func (o *Instance) addCloser(v any) {
+	switch T := any(v).(type) {
+	case func():
+		o.closers = append(o.closers, T)
+	case interface{ Close() }:
+		o.closers = append(o.closers, func() { T.Close() })
+	}
+}
+
+func Do(
+	ctx context.Context,
+	method string,
+	url string,
+	req, res any,
+) error {
+	var rdr io.Reader
+	if req != nil {
+		buf := new(bytes.Buffer)
+		err := json.NewEncoder(buf).Encode(req)
+		if err != nil {
+			return err
+		}
+		rdr = buf
+	}
+
+	data, err := do(ctx, method, url, rdr)
+	if err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, res); err != nil {
+		return err
+	}
+	return nil
+}
+
+func do(
+	ctx context.Context,
+	method string,
+	url string,
+	body io.Reader,
+) ([]byte, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, method, url, body)
+	if err != nil {
+		return nil, err
+	}
+
+	h := httpReq.Header
+	h.Add("X-Client-Info", "auth-go/v1.0.0")
+	h.Add("X-Supabase-Api-Version", "2024-01-01")
+	h.Add("Content-Type", "application/json")
+	h.Add("Accept", "application/json")
+
+	httpRes, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+	defer httpRes.Body.Close()
+
+	switch sc := httpRes.StatusCode; {
+	case sc == http.StatusNoContent:
+		return nil, nil
+
+	case sc >= 400:
+		data, err := io.ReadAll(io.LimitReader(httpRes.Body, 1e8))
+		if err != nil {
+			return nil, err
+		}
+
+		apiErr := new(api.HTTPErrorResponse20240101)
+		if err := json.Unmarshal(data, apiErr); err != nil {
+			return nil, err
+		}
+
+		err = &apierrors.HTTPError{
+			HTTPStatus: sc,
+			ErrorCode:  apiErr.Code,
+			Message:    apiErr.Message,
+		}
+		return nil, err
+
+	default:
+		data, err := io.ReadAll(io.LimitReader(httpRes.Body, 1e8))
+		if err != nil {
+			return nil, err
+		}
+		return data, nil
+	}
+}