test: add coverage baseline and unit tests

Author: mamchurovskyy

src/app/app.go

@@ -20,9 +20,10 @@ import (
 )
 
 type App struct {
-	params *param.Params
-	server *http.Server
-	cache  *lru.TwoQueueCache
+	params         *param.Params
+	server         *http.Server
+	cache          *lru.TwoQueueCache
+	listenAndServe func(*http.Server) error
 }
 
 type ResponseItem struct {
@@ -42,6 +43,10 @@ const (
 )
 
 func NewApp(params *param.Params) App {
+	return NewAppWithListenAndServe(params, nil)
+}
+
+func NewAppWithListenAndServe(params *param.Params, listenAndServe func(*http.Server) error) App {
 	var cache *lru.TwoQueueCache = nil
 	var err error
 
@@ -52,7 +57,18 @@ func NewApp(params *param.Params) App {
 		}
 	}
 
-	return App{params: params, server: nil, cache: cache}
+	if listenAndServe == nil {
+		listenAndServe = func(server *http.Server) error {
+			return server.ListenAndServe()
+		}
+	}
+
+	return App{
+		params:         params,
+		server:         nil,
+		cache:          cache,
+		listenAndServe: listenAndServe,
+	}
 }
 
 func (app *App) ShouldSkipCompression(filePath string) bool {
@@ -312,7 +328,7 @@ func (app *App) Listen() {
 	}
 
 	fmt.Printf("Server listening on http://%s\n", app.server.Addr)
-	err := app.server.ListenAndServe()
+	err := app.listenAndServe(app.server)
 	if err != nil {
 		panic(err)
 	}

src/main.go

@@ -8,7 +8,21 @@ import (
 	"os"
 )
 
-func main() {
+type AppRunner interface {
+	CompressFiles()
+	Listen()
+}
+
+func defaultNewRunner(params *param.Params) AppRunner {
+	newApp := app.NewApp(params)
+	return &newApp
+}
+
+func run(args []string, newRunner func(*param.Params) AppRunner) error {
+	if newRunner == nil {
+		newRunner = defaultNewRunner
+	}
+
 	cliApp := &cli.App{
 		Name:  "spa-to-http",
 		Flags: param.Flags,
@@ -18,15 +32,19 @@ func main() {
 				return err
 			}
 
-			newApp := app.NewApp(params)
+			newApp := newRunner(params)
 			go newApp.CompressFiles()
 			newApp.Listen()
 
 			return nil
 		},
 	}
 
-	if err := cliApp.Run(os.Args); err != nil {
+	return cliApp.Run(args)
+}
+
+func main() {
+	if err := run(os.Args, nil); err != nil {
 		log.Fatal(err)
 	}
 }

src/param/param.go

@@ -106,7 +106,11 @@ type Params struct {
 }
 
 func ContextToParams(c *cli.Context) (*Params, error) {
-	directory, err := filepath.Abs(c.String("directory"))
+	return ContextToParamsWithAbs(c, filepath.Abs)
+}
+
+func ContextToParamsWithAbs(c *cli.Context, abs func(string) (string, error)) (*Params, error) {
+	directory, err := abs(c.String("directory"))
 	if err != nil {
 		return nil, err
 	}

src/param/param_test.go

@@ -2,9 +2,11 @@ package param_test
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"go-http-server/param"
 	"path/filepath"
+	"reflect"
 	"testing"
 
 	"github.com/urfave/cli/v2"
@@ -20,9 +22,12 @@ func TestContextToParams(t *testing.T) {
 	e_directory := "example dir"
 	e_cache_control_max_age := int64(2048)
 	e_spa := true
-	e_ignore_cache_control_paths := "example path1"
+	e_ignore_cache_control_paths := []string{"example path1", "example path2"}
 	e_cache := true
 	e_cache_buffer := 64
+	e_logger := true
+	e_log_pretty := true
+	e_no_compress := []string{".map", ".zip"}
 
 	f.String("address", e_adress, "")
 	f.Int("port", e_port, "")
@@ -32,9 +37,12 @@ func TestContextToParams(t *testing.T) {
 	f.String("directory", e_directory, "")
 	f.Int64("cache-max-age", e_cache_control_max_age, "")
 	f.Bool("spa", e_spa, "")
-	f.String("ignore-cache-control-paths", e_ignore_cache_control_paths, "")
+	f.Var(cli.NewStringSlice(e_ignore_cache_control_paths...), "ignore-cache-control-paths", "")
 	f.Bool("cache", e_cache, "")
 	f.Int("cache-buffer", e_cache_buffer, "")
+	f.Bool("logger", e_logger, "")
+	f.Bool("log-pretty", e_log_pretty, "")
+	f.Var(cli.NewStringSlice(e_no_compress...), "no-compress", "")
 
 	ctx := cli.NewContext(nil, f, nil)
 	ctx.Context = context.WithValue(context.Background(), "key", "val")
@@ -77,11 +85,9 @@ func TestContextToParams(t *testing.T) {
 		t.Errorf("Got %t, expected %t", params.SpaMode, e_spa)
 	}
 
-	//TODO
-	// fmt.Println(params.IgnoreCacheControlPaths)
-	// if params.IgnoreCacheControlPaths[0] != e_ignore_cache_control_paths {
-	// 	t.Errorf("Got %s, expected %s", params.IgnoreCacheControlPaths, e_ignore_cache_control_paths)
-	// }
+	if !reflect.DeepEqual(params.IgnoreCacheControlPaths, e_ignore_cache_control_paths) {
+		t.Errorf("Got %v, expected %v", params.IgnoreCacheControlPaths, e_ignore_cache_control_paths)
+	}
 
 	if params.CacheEnabled != e_cache {
 		t.Errorf("Got %t, expected %t", params.CacheEnabled, e_cache)
@@ -90,4 +96,38 @@ func TestContextToParams(t *testing.T) {
 	if params.CacheBuffer != e_cache_buffer {
 		t.Errorf("Got %d, expected %d", params.CacheBuffer, e_cache_buffer)
 	}
+
+	if params.Logger != e_logger {
+		t.Errorf("Got %t, expected %t", params.Logger, e_logger)
+	}
+
+	if params.LogPretty != e_log_pretty {
+		t.Errorf("Got %t, expected %t", params.LogPretty, e_log_pretty)
+	}
+
+	if !reflect.DeepEqual(params.NoCompress, e_no_compress) {
+		t.Errorf("Got %v, expected %v", params.NoCompress, e_no_compress)
+	}
+}
+
+func TestContextToParamsWithAbsError(t *testing.T) {
+	f := flag.NewFlagSet("a", flag.ContinueOnError)
+	f.String("directory", "example", "")
+
+	ctx := cli.NewContext(nil, f, nil)
+	ctx.Context = context.WithValue(context.Background(), "key", "val")
+
+	expectedErr := errors.New("abs failed")
+	params, err := param.ContextToParamsWithAbs(ctx, func(_ string) (string, error) {
+		return "", expectedErr
+	})
+	if err == nil {
+		t.Fatalf("Expected error, got nil")
+	}
+	if !errors.Is(err, expectedErr) {
+		t.Fatalf("Expected error %v, got %v", expectedErr, err)
+	}
+	if params != nil {
+		t.Fatalf("Expected params to be nil on error, got %v", params)
+	}
 }

src/util/log_test.go

@@ -373,3 +373,34 @@ func TestLogRequestHandlerNilOptions(t *testing.T) {
 		t.Errorf("expected log output, got empty string")
 	}
 }
+
+func TestLogRequestHandlerWithLoggerOverride(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewJSONHandler(&buf, nil))
+
+	dummyHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	handler := LogRequestHandler(dummyHandler, &LogRequestHandlerOptions{
+		Logger: logger,
+	})
+
+	req := httptest.NewRequest("GET", "/logger-override", nil)
+	req.RemoteAddr = "127.0.0.1:8080"
+	wr := httptest.NewRecorder()
+	handler.ServeHTTP(wr, req)
+
+	logged := buf.String()
+	if len(logged) == 0 {
+		t.Fatalf("expected log output, got empty string")
+	}
+
+	var logData map[string]interface{}
+	if err := json.Unmarshal([]byte(logged), &logData); err != nil {
+		t.Fatalf("failed to parse log output as JSON: %v", err)
+	}
+	if path, ok := logData["path"]; !ok || path != "/logger-override" {
+		t.Errorf("expected path '/logger-override', got %v", path)
+	}
+}

src/util/util.go

@@ -28,9 +28,19 @@ func GetFileType(path string) FileType {
 }
 
 func GetFileWithInfoAndType(path string) (http.File, fs.FileInfo, FileType) {
+	return GetFileWithInfoAndTypeWithOpener(path, nil)
+}
+
+func GetFileWithInfoAndTypeWithOpener(path string, opener func(string, string) (http.File, error)) (http.File, fs.FileInfo, FileType) {
+	if opener == nil {
+		opener = func(dirPath, fileName string) (http.File, error) {
+			fsDir := http.Dir(dirPath)
+			return fsDir.Open(fileName)
+		}
+	}
+
 	dirPath, fileName := filepath.Split(path)
-	fsDir := http.Dir(dirPath)
-	file, err := fsDir.Open(fileName)
+	file, err := opener(dirPath, fileName)
 
 	if err != nil {
 		return nil, nil, FileTypeNotExists

src/util/util_test.go

@@ -1,7 +1,11 @@
 package util_test
 
 import (
+	"errors"
 	"go-http-server/util"
+	"io"
+	"io/fs"
+	"net/http"
 	"testing"
 )
 
@@ -58,3 +62,32 @@ func TestGetFileType(t *testing.T) {
 		}
 	}
 }
+
+type badStatFile struct{}
+
+func (f *badStatFile) Close() error                       { return nil }
+func (f *badStatFile) Read(_ []byte) (int, error)         { return 0, io.EOF }
+func (f *badStatFile) Seek(_ int64, _ int) (int64, error) { return 0, nil }
+func (f *badStatFile) Readdir(_ int) ([]fs.FileInfo, error) {
+	return nil, nil
+}
+func (f *badStatFile) Stat() (fs.FileInfo, error) {
+	return nil, errors.New("stat failed")
+}
+
+func TestGetFileWithInfoAndTypeWithOpenerStatError(t *testing.T) {
+	opener := func(_, _ string) (http.File, error) {
+		return &badStatFile{}, nil
+	}
+
+	file, info, fileType := util.GetFileWithInfoAndTypeWithOpener("irrelevant", opener)
+	if file != nil {
+		t.Errorf("Expected file = nil, got %v", file)
+	}
+	if info != nil {
+		t.Errorf("Expected info = nil, got %v", info)
+	}
+	if fileType != util.FileTypeNotExists {
+		t.Errorf("Expected FileTypeNotExists, got %v", fileType)
+	}
+}