test: reach 100% coverage

Author: mamchurovskyy

src/app/app_test.go

@@ -101,6 +101,7 @@ func TestCompressFiles(t *testing.T) {
 		os.Remove("app_internal_test.go.br")
 		os.Remove("auth.go.br")
 		os.Remove("auth_test.go.br")
+		os.Remove("auth_internal_test.go.br")
 		os.Remove("app.go.br")
 
 		params.Directory = "../../test/frontend/dist/vite.svg.br"

src/app/auth_internal_test.go

@@ -0,0 +1,85 @@
+package app
+
+import (
+	"go-http-server/param"
+	"net/http"
+	"os"
+	"testing"
+)
+
+func TestAuthLoggerDisabled(t *testing.T) {
+	params := param.Params{
+		Logger: false,
+	}
+	app := NewApp(&params)
+	if logger := app.authLogger(); logger != nil {
+		t.Fatalf("expected nil logger when disabled")
+	}
+}
+
+func TestAuthLoggerLevelsAndFormats(t *testing.T) {
+	tests := []struct {
+		name     string
+		logLevel string
+		pretty   bool
+	}{
+		{"debug json", "debug", false},
+		{"warn pretty", "warn", true},
+		{"error json", "error", false},
+		{"default info pretty", "", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			orig := os.Getenv("LOG_LEVEL")
+			if tt.logLevel == "" {
+				_ = os.Unsetenv("LOG_LEVEL")
+			} else {
+				_ = os.Setenv("LOG_LEVEL", tt.logLevel)
+			}
+			t.Cleanup(func() {
+				if orig == "" {
+					_ = os.Unsetenv("LOG_LEVEL")
+				} else {
+					_ = os.Setenv("LOG_LEVEL", orig)
+				}
+			})
+
+			params := param.Params{
+				Logger:    true,
+				LogPretty: tt.pretty,
+			}
+			app := NewApp(&params)
+			logger := app.authLogger()
+			if logger == nil {
+				t.Fatalf("expected logger, got nil")
+			}
+		})
+	}
+}
+
+func TestListenWithAuthAndLoggerEnabled(t *testing.T) {
+	params := param.Params{
+		BasicAuthEnabled: true,
+		BasicAuthUser:    "user",
+		BasicAuthPass:    "pass",
+		Logger:           true,
+		LogPretty:        true,
+		Address:          "127.0.0.1",
+		Port:             8085,
+	}
+
+	called := false
+	app := NewAppWithListenAndServe(&params, func(server *http.Server) error {
+		if server == nil || server.Handler == nil {
+			t.Fatalf("expected server and handler to be set")
+		}
+		called = true
+		return nil
+	})
+
+	app.Listen()
+	if !called {
+		t.Fatalf("expected listenAndServe to be called")
+	}
+}

src/app/auth_test.go

@@ -4,6 +4,7 @@ import (
 	"go-http-server/param"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"testing"
 )
 
@@ -54,6 +55,41 @@ func TestBasicAuthMiddlewareMissingHeader(t *testing.T) {
 	}
 }
 
+func TestBasicAuthMiddlewareMissingHeaderWithLogger(t *testing.T) {
+	orig := os.Getenv("LOG_LEVEL")
+	_ = os.Setenv("LOG_LEVEL", "debug")
+	t.Cleanup(func() {
+		if orig == "" {
+			_ = os.Unsetenv("LOG_LEVEL")
+		} else {
+			_ = os.Setenv("LOG_LEVEL", orig)
+		}
+	})
+
+	params := param.Params{
+		BasicAuthEnabled: true,
+		BasicAuthUser:    "user",
+		BasicAuthPass:    "pass",
+		Logger:           true,
+	}
+	app := NewApp(&params)
+
+	handler := app.BasicAuthMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	req := httptest.NewRequest("GET", "/", nil)
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("expected status %d, got %d", http.StatusUnauthorized, rec.Code)
+	}
+	if got := rec.Header().Get("WWW-Authenticate"); got != "Basic realm=\"Restricted\"" {
+		t.Fatalf("expected realm header, got %s", got)
+	}
+}
+
 func TestBasicAuthMiddlewareWrongCredentials(t *testing.T) {
 	params := param.Params{
 		BasicAuthEnabled: true,
@@ -105,3 +141,37 @@ func TestBasicAuthMiddlewareSuccess(t *testing.T) {
 		t.Fatalf("expected body ok, got %s", rec.Body.String())
 	}
 }
+
+func TestBasicAuthMiddlewareWithLoggerEnabled(t *testing.T) {
+	orig := os.Getenv("LOG_LEVEL")
+	_ = os.Setenv("LOG_LEVEL", "debug")
+	t.Cleanup(func() {
+		if orig == "" {
+			_ = os.Unsetenv("LOG_LEVEL")
+		} else {
+			_ = os.Setenv("LOG_LEVEL", orig)
+		}
+	})
+
+	params := param.Params{
+		BasicAuthEnabled: true,
+		BasicAuthUser:    "user",
+		BasicAuthPass:    "pass",
+		Logger:           true,
+		LogPretty:        true,
+	}
+	app := NewApp(&params)
+
+	handler := app.BasicAuthMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	req := httptest.NewRequest("GET", "/", nil)
+	req.SetBasicAuth("user", "pass")
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected status %d, got %d", http.StatusOK, rec.Code)
+	}
+}

src/param/param_test.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"errors"
 	"flag"
+	"github.com/urfave/cli/v2"
 	"go-http-server/param"
 	"path/filepath"
 	"reflect"
 	"testing"
-	"github.com/urfave/cli/v2"
 )
 
 func TestContextToParams(t *testing.T) {
@@ -179,3 +179,48 @@ func TestContextToParamsInvalidBasicAuthFormat(t *testing.T) {
 		})
 	}
 }
+
+func TestContextToParamsBasicAuthDefaultRealm(t *testing.T) {
+	f := flag.NewFlagSet("a", flag.ContinueOnError)
+	f.String("directory", "example", "")
+	f.String("basic-auth", "user:pass", "")
+
+	ctx := cli.NewContext(nil, f, nil)
+	ctx.Context = context.WithValue(context.Background(), "key", "val")
+
+	params, err := param.ContextToParamsWithAbs(ctx, func(s string) (string, error) {
+		return s, nil
+	})
+	if err != nil {
+		t.Fatalf("expected nil error, got %v", err)
+	}
+	if !params.BasicAuthEnabled {
+		t.Fatalf("expected basic auth enabled")
+	}
+	if params.BasicAuthRealm != "Restricted" {
+		t.Fatalf("expected default realm Restricted, got %s", params.BasicAuthRealm)
+	}
+}
+
+func TestContextToParamsBasicAuthDisabledWhenEmpty(t *testing.T) {
+	f := flag.NewFlagSet("a", flag.ContinueOnError)
+	f.String("directory", "example", "")
+	f.String("basic-auth", "", "")
+	f.String("basic-auth-realm", "ShouldNotApply", "")
+
+	ctx := cli.NewContext(nil, f, nil)
+	ctx.Context = context.WithValue(context.Background(), "key", "val")
+
+	params, err := param.ContextToParamsWithAbs(ctx, func(s string) (string, error) {
+		return s, nil
+	})
+	if err != nil {
+		t.Fatalf("expected nil error, got %v", err)
+	}
+	if params.BasicAuthEnabled {
+		t.Fatalf("expected basic auth disabled")
+	}
+	if params.BasicAuthRealm != "ShouldNotApply" {
+		t.Fatalf("expected realm value to be preserved, got %s", params.BasicAuthRealm)
+	}
+}