[feature] pkg, env, and boost: Unit tests + Coverage Workflow

.github/workflows/tests.yml

@@ -0,0 +1,48 @@
+name: Tests
+
+on:
+  pull_request:
+    types: [ready_for_review, synchronize, labeled]
+
+jobs:
+  test:
+    if: github.event.pull_request.draft == false || (github.event.action == 'labeled' && github.event.label.name == 'testing')
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: [1.24.x]
+    steps:
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+
+      - uses: actions/checkout@v4
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Run pkg tests
+        run: |
+          go test ./pkg/... -coverprofile=coverage.out
+          go tool cover -func=coverage.out | tail -n 1
+
+      - name: Run boost & env tests
+        run: |
+          go test ./boost ./env -coverprofile=coverage.out
+          go tool cover -func=coverage.out | tail -n 1
+
+      - name: Run handlers tests
+        run: |
+          go test ./handler/... -coverprofile=coverage.out
+          go tool cover -func=coverage.out | tail -n 1
+
+      - name: Run database tests
+        run: |
+          go test ./database/... -coverprofile=coverage.out
+          go tool cover -func=coverage.out | tail -n 1

boost/boost_test.go

@@ -0,0 +1,262 @@
+package boost
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/oullin/database"
+	"github.com/oullin/database/repository"
+	"github.com/oullin/pkg"
+	"github.com/oullin/pkg/auth"
+	"github.com/oullin/pkg/http/middleware"
+	"github.com/oullin/pkg/llogs"
+)
+
+func validEnvVars(t *testing.T) {
+	t.Setenv("ENV_APP_NAME", "guss")
+	t.Setenv("ENV_APP_ENV_TYPE", "local")
+	t.Setenv("ENV_APP_MASTER_KEY", "12345678901234567890123456789012")
+	t.Setenv("ENV_DB_USER_NAME", "usernamefoo")
+	t.Setenv("ENV_DB_USER_PASSWORD", "passwordfoo")
+	t.Setenv("ENV_DB_DATABASE_NAME", "dbnamefoo")
+	t.Setenv("ENV_DB_PORT", "5432")
+	t.Setenv("ENV_DB_HOST", "localhost")
+	t.Setenv("ENV_DB_SSL_MODE", "require")
+	t.Setenv("ENV_DB_TIMEZONE", "UTC")
+	t.Setenv("ENV_APP_LOG_LEVEL", "debug")
+	t.Setenv("ENV_APP_LOGS_DIR", "logs_%s.log")
+	t.Setenv("ENV_APP_LOGS_DATE_FORMAT", "2006_01_02")
+	t.Setenv("ENV_HTTP_HOST", "localhost")
+	t.Setenv("ENV_HTTP_PORT", "8080")
+	t.Setenv("ENV_SENTRY_DSN", "dsn")
+	t.Setenv("ENV_SENTRY_CSP", "csp")
+}
+
+func TestMakeEnv(t *testing.T) {
+	validEnvVars(t)
+
+	env := MakeEnv(pkg.GetDefaultValidator())
+
+	if env.App.Name != "guss" {
+		t.Fatalf("env not loaded")
+	}
+}
+
+func TestIgnite(t *testing.T) {
+	content := "ENV_APP_NAME=guss\n" +
+		"ENV_APP_ENV_TYPE=local\n" +
+		"ENV_APP_MASTER_KEY=12345678901234567890123456789012\n" +
+		"ENV_DB_USER_NAME=usernamefoo\n" +
+		"ENV_DB_USER_PASSWORD=passwordfoo\n" +
+		"ENV_DB_DATABASE_NAME=dbnamefoo\n" +
+		"ENV_DB_PORT=5432\n" +
+		"ENV_DB_HOST=localhost\n" +
+		"ENV_DB_SSL_MODE=require\n" +
+		"ENV_DB_TIMEZONE=UTC\n" +
+		"ENV_APP_LOG_LEVEL=debug\n" +
+		"ENV_APP_LOGS_DIR=logs_%s.log\n" +
+		"ENV_APP_LOGS_DATE_FORMAT=2006_01_02\n" +
+		"ENV_HTTP_HOST=localhost\n" +
+		"ENV_HTTP_PORT=8080\n" +
+		"ENV_SENTRY_DSN=dsn\n" +
+		"ENV_SENTRY_CSP=csp\n"
+
+	f, err := os.CreateTemp("", "envfile")
+	if err != nil {
+		t.Fatalf("temp file err: %v", err)
+	}
+	defer os.Remove(f.Name())
+	f.WriteString(content)
+	f.Close()
+
+	env := Ignite(f.Name(), pkg.GetDefaultValidator())
+
+	if env.Network.HttpPort != "8080" {
+		t.Fatalf("env not loaded")
+	}
+}
+
+func TestAppBootNil(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Fatalf("expected panic")
+		}
+	}()
+
+	var a *App
+	a.Boot()
+}
+
+func TestAppHelpers(t *testing.T) {
+	app := &App{}
+	mux := http.NewServeMux()
+	r := Router{Mux: mux}
+	app.SetRouter(r)
+
+	if app.GetMux() != mux {
+		t.Fatalf("mux not set")
+	}
+
+	app.CloseLogs()
+	app.CloseDB()
+
+	if app.GetEnv() != nil {
+		t.Fatalf("expected nil env")
+	}
+	if app.GetDB() != nil {
+		t.Fatalf("expected nil db")
+	}
+}
+func TestAppBootRoutes(t *testing.T) {
+	validEnvVars(t)
+
+	env := MakeEnv(pkg.GetDefaultValidator())
+
+	key, err := auth.GenerateAESKey()
+	if err != nil {
+		t.Fatalf("key err: %v", err)
+	}
+
+	handler, err := auth.MakeTokensHandler(key)
+	if err != nil {
+		t.Fatalf("handler err: %v", err)
+	}
+
+	router := Router{
+		Env: env,
+		Mux: http.NewServeMux(),
+		Pipeline: middleware.Pipeline{
+			Env:          env,
+			ApiKeys:      &repository.ApiKeys{DB: &database.Connection{}},
+			TokenHandler: handler,
+		},
+		Db: &database.Connection{},
+	}
+
+	app := &App{}
+	app.SetRouter(router)
+
+	app.Boot()
+
+	routes := []struct {
+		method string
+		path   string
+	}{
+		{"GET", "/profile"},
+		{"GET", "/experience"},
+		{"GET", "/projects"},
+		{"GET", "/social"},
+		{"GET", "/talks"},
+		{"GET", "/education"},
+		{"GET", "/recommendations"},
+		{"POST", "/posts"},
+		{"GET", "/posts/slug"},
+		{"GET", "/categories"},
+	}
+
+	for _, rt := range routes {
+		req := httptest.NewRequest(rt.method, rt.path, nil)
+		h, pattern := app.GetMux().Handler(req)
+		if pattern == "" || h == nil {
+			t.Fatalf("route missing %s %s", rt.method, rt.path)
+		}
+	}
+}
+
+func TestMakeLogs(t *testing.T) {
+	dir, err := os.MkdirTemp("", "logdir")
+	if err != nil {
+		t.Fatalf("tmpdir err: %v", err)
+	}
+
+	validEnvVars(t)
+	t.Setenv("ENV_APP_LOGS_DIR", filepath.Join(dir, "log-%s.txt"))
+
+	env := MakeEnv(pkg.GetDefaultValidator())
+
+	d := MakeLogs(env)
+	driver := *d
+	fl := driver.(llogs.FilesLogs)
+
+	if !strings.HasPrefix(fl.DefaultPath(), dir) {
+		t.Fatalf("wrong log dir")
+	}
+
+	if !fl.Close() {
+		t.Fatalf("close failed")
+	}
+}
+
+func TestMakeDbConnectionPanic(t *testing.T) {
+	validEnvVars(t)
+	t.Setenv("ENV_DB_PORT", "1")
+	t.Setenv("ENV_SENTRY_DSN", "https://public@o0.ingest.sentry.io/0")
+
+	env := MakeEnv(pkg.GetDefaultValidator())
+
+	defer func() {
+		if r := recover(); r == nil {
+			t.Fatalf("expected panic")
+		}
+	}()
+
+	MakeDbConnection(env)
+}
+
+func TestMakeAppPanic(t *testing.T) {
+	validEnvVars(t)
+	t.Setenv("ENV_DB_PORT", "1")
+	t.Setenv("ENV_APP_LOGS_DIR", "/tmp/log-%s.txt")
+	t.Setenv("ENV_SENTRY_DSN", "https://public@o0.ingest.sentry.io/0")
+
+	env := MakeEnv(pkg.GetDefaultValidator())
+
+	defer func() {
+		if r := recover(); r == nil {
+			t.Fatalf("expected panic")
+		}
+	}()
+
+	MakeApp(env, pkg.GetDefaultValidator())
+}
+
+func TestMakeSentry(t *testing.T) {
+	validEnvVars(t)
+	t.Setenv("ENV_SENTRY_DSN", "https://public@o0.ingest.sentry.io/0")
+
+	env := MakeEnv(pkg.GetDefaultValidator())
+
+	s := MakeSentry(env)
+	if s == nil || s.Handler == nil || s.Options == nil {
+		t.Fatalf("sentry setup failed")
+	}
+}
+
+func TestCloseLogs(t *testing.T) {
+	dir, err := os.MkdirTemp("", "logdir")
+	if err != nil {
+		t.Fatalf("tmpdir err: %v", err)
+	}
+
+	validEnvVars(t)
+	t.Setenv("ENV_APP_LOGS_DIR", filepath.Join(dir, "log-%s.txt"))
+	t.Setenv("ENV_SENTRY_DSN", "https://public@o0.ingest.sentry.io/0")
+
+	env := MakeEnv(pkg.GetDefaultValidator())
+
+	l := MakeLogs(env)
+	app := &App{logs: l}
+
+	app.CloseLogs()
+}
+
+func TestGetMuxNil(t *testing.T) {
+	app := &App{}
+	if app.GetMux() != nil {
+		t.Fatalf("expected nil mux")
+	}
+}

boost/factory.go

@@ -93,23 +93,23 @@ func MakeEnv(validate *pkg.Validator) *env.Environment {
 	}
 
 	if _, err := validate.Rejects(app); err != nil {
-		panic(errorSuffix + "invalid [APP] model: " + validate.GetErrorsAsJason())
+		panic(errorSuffix + "invalid [APP] model: " + validate.GetErrorsAsJson())
 	}
 
 	if _, err := validate.Rejects(db); err != nil {
-		panic(errorSuffix + "invalid [Sql] model: " + validate.GetErrorsAsJason())
+		panic(errorSuffix + "invalid [Sql] model: " + validate.GetErrorsAsJson())
 	}
 
 	if _, err := validate.Rejects(logsCreds); err != nil {
-		panic(errorSuffix + "invalid [logs Creds] model: " + validate.GetErrorsAsJason())
+		panic(errorSuffix + "invalid [logs Creds] model: " + validate.GetErrorsAsJson())
 	}
 
 	if _, err := validate.Rejects(net); err != nil {
-		panic(errorSuffix + "invalid [NETWORK] model: " + validate.GetErrorsAsJason())
+		panic(errorSuffix + "invalid [NETWORK] model: " + validate.GetErrorsAsJson())
 	}
 
 	if _, err := validate.Rejects(sentryEnvironment); err != nil {
-		panic(errorSuffix + "invalid [SENTRY] model: " + validate.GetErrorsAsJason())
+		panic(errorSuffix + "invalid [SENTRY] model: " + validate.GetErrorsAsJson())
 	}
 
 	blog := &env.Environment{
@@ -121,7 +121,7 @@ func MakeEnv(validate *pkg.Validator) *env.Environment {
 	}
 
 	if _, err := validate.Rejects(blog); err != nil {
-		panic(errorSuffix + "invalid blog [ENVIRONMENT] model: " + validate.GetErrorsAsJason())
+		panic(errorSuffix + "invalid blog [ENVIRONMENT] model: " + validate.GetErrorsAsJson())
 	}
 
 	return blog

cli/panel/menu.go

@@ -175,7 +175,7 @@ func (p *Menu) CapturePostURL() (*posts.Input, error) {
 			cli.Reset,
 			cli.BlueColour,
 			cli.Reset,
-			validate.GetErrorsAsJason(),
+			validate.GetErrorsAsJson(),
 		)
 	}