feat: custom status response/test improvement

Author: rellyson

.github/workflows/ci.yml

@@ -36,17 +36,17 @@ jobs:
       - name: Build
         run: task build
 
-      - name: Lint with golangci-lint
-        run: golangci-lint run ./...
+      - name: Lint
+        run: task lint
 
-      # - name: Test with go
-      #   run: go test ./... -json > TestResults-${{ matrix.go-version }}.json
+      - name: Test cov
+        run: task test-cov-html
 
-      # - name: Upload test results
-      #   uses: actions/upload-artifact@v4
-      #   with:
-      #     name: go-results-${{ matrix.go-version }}
-      #     path: TestResults-${{ matrix.go-version }}.json
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        with:
+          name: go-results-${{ matrix.go-version }}
+          path: cov/coverage.html
 
   build-and-push-image:
     runs-on: ubuntu-latest

.gitignore

@@ -16,6 +16,11 @@ tmp/
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
+# go cover output
+*.coverprofile
+*.cov
+cov/
+
 # Dependency directories (remove the comment below to include it)
 # vendor/
 

CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] - 2025-01-24
+
+### Added
+
+Custom status code response
+
+### Fixed
+
+Unit tests
+
+
 ## [0.2.0] - 2025-01-23
 
 ### Added
@@ -13,6 +24,7 @@ Application handlers
 Application middlewares
 Utils added
 
+
 ## [0.1.0] - 2025-01-22
 
 Initial project release

README.md

@@ -24,7 +24,8 @@ The HTTP Echo server provides the following features:
   - **queries**: query parameters
   - **params**: path parameters
   - **body**: request body
-- Returns a custom status code for a request (provided via query) - **TBD**.
+- Returns a custom status code for a request (provided via query).
+  - E.g. `http://127.0.0.1:3000/?status=404` returns a `404` response code.
 - Exports metrics in `prometheus` format for monitoring.
 
 ## Usage

Taskfile.yml

@@ -5,6 +5,26 @@ tasks:
     desc: "Build the server binary"
     cmd: "go build -o bin/http-echo ./cmd/server/main.go"
 
+  lint:
+    desc: "Lint the source code"
+    cmd: "golangci-lint run ./..."
+
+  test:
+    desc: "Run the unit tests"
+    cmd: "go test ./..."
+
+  test-cov:
+    desc: "Run the unit tests with coverage"
+    cmd: "go test -coverprofile=coverage.out ./..."
+
+  test-cov-html:
+    deps:
+      - test-cov
+    desc: "Generate the HTML coverage report"
+    cmds:
+      - "mkdir -p cov"
+      - "go tool cover -html=coverage.out -o cov/coverage.html"
+
   docker-build:
     desc: "Build the docker image"
     cmd: "docker build -t rellyson/http-echo ."

VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

internal/handlers/echo.go

@@ -5,16 +5,14 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 
 	"github.com/rellyson/http-echo/pkg/netutils"
-	"github.com/rellyson/http-echo/pkg/version"
 )
 
 const (
-	httpHeaderAppName    = "X-App-Name"
-	httpHeaderAppVersion = "X-App-Version"
-	httpHeaderAppBuild   = "X-App-Build"
+	httpHeaderAppName = "X-App-Name"
 )
 
 // EchoResponse is the response for the echo request.
@@ -45,8 +43,22 @@ func Echo(w http.ResponseWriter, r *http.Request) {
 		panic(err)
 	}
 
-	setHeaders(w)
-	w.WriteHeader(http.StatusOK)
+	statusCode := http.StatusOK
+
+	// set custom status code if query parameter is set
+	if r.URL.Query().Get("status") != "" {
+		s, err := strconv.Atoi(r.URL.Query().Get("status"))
+
+		if err != nil {
+			panic(err)
+		} else {
+			statusCode = s
+		}
+	}
+
+	w.Header().Set(httpHeaderAppName, "http-echo")
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(statusCode)
 
 	response := &EchoResponse{
 		HostInfo: HostInfoResponse{
@@ -66,20 +78,6 @@ func Echo(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-// setHeaders sets the headers for the response.
-func setHeaders(w http.ResponseWriter) {
-	v, err := version.GetVersion()
-
-	if err != nil {
-		panic(err)
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set(httpHeaderAppName, "http-echo")
-	w.Header().Set(httpHeaderAppVersion, v.Version)
-	w.Header().Set(httpHeaderAppBuild, v.Build)
-}
-
 // mapHeaders maps the headers to a map.
 func mapHeaders(h http.Header) map[string]string {
 	headers := make(map[string]string)

internal/handlers/echo_test.go

@@ -17,13 +17,15 @@ func TestEcho(t *testing.T) {
 		method         string
 		path           string
 		headers        map[string]string
+		parameters     []string
+		queries        map[string]string
 		body           interface{}
 		expectedStatus int
 	}{
 		{
 			name:           "GET request with no parameters",
 			method:         "GET",
-			path:           "/echo",
+			path:           "/",
 			expectedStatus: http.StatusOK,
 		},
 		{
@@ -39,11 +41,31 @@ func TestEcho(t *testing.T) {
 			expectedStatus: http.StatusOK,
 		},
 		{
-			name:           "GET request with query parameters",
+			name:   "GET request with query parameters",
+			method: "GET",
+			path:   "/echo?param1=value1&param2=value2",
+			queries: map[string]string{
+				"param1": "value1",
+				"param2": "value2",
+			},
+			expectedStatus: http.StatusOK,
+		},
+		{
+			name:           "GET request with path parameters",
 			method:         "GET",
-			path:           "/echo?param1=value1¶m2=value2",
+			path:           "/echo/param1/param2",
+			parameters:     []string{"param1", "param2"},
 			expectedStatus: http.StatusOK,
 		},
+		{
+			name:   "GET request with custom status code",
+			method: "GET",
+			path:   "/?status=404",
+			queries: map[string]string{
+				"status": "404",
+			},
+			expectedStatus: http.StatusNotFound,
+		},
 	}
 
 	for _, tt := range tests {
@@ -68,16 +90,25 @@ func TestEcho(t *testing.T) {
 			assert.Equal(t, tt.expectedStatus, resp.StatusCode)
 			assert.Equal(t, "application/json", resp.Header.Get("Content-Type"))
 			assert.NotEmpty(t, resp.Header.Get(httpHeaderAppName))
-			assert.NotEmpty(t, resp.Header.Get(httpHeaderAppVersion))
-			assert.NotEmpty(t, resp.Header.Get(httpHeaderAppBuild))
 
 			var response EchoResponse
 			err := json.NewDecoder(resp.Body).Decode(&response)
 			assert.NoError(t, err)
 
 			assert.NotEmpty(t, response.HostInfo.Hostname)
 			assert.NotEmpty(t, response.HostInfo.IP)
-			assert.NotEmpty(t, response.HttpInfo.Headers)
+
+			if tt.headers != nil {
+				assert.NotEmpty(t, response.HttpInfo.Headers)
+			}
+
+			if tt.parameters != nil {
+				assert.NotEmpty(t, response.HttpInfo.Params)
+			}
+
+			if tt.queries != nil {
+				assert.NotEmpty(t, response.HttpInfo.Queries)
+			}
 
 			if tt.body != nil {
 				assert.NotNil(t, response.HttpInfo.Body)
@@ -103,7 +134,7 @@ func TestMapHeaders(t *testing.T) {
 }
 
 func TestMapQuery(t *testing.T) {
-	url := "http://example.com?param1=value1¶m2=value2"
+	url := "http://example.com?param1=value1&param2=value2"
 	req, _ := http.NewRequest("GET", url, nil)
 
 	result := mapQuery(req.URL.Query())
@@ -135,9 +166,9 @@ func TestMapBody(t *testing.T) {
 			},
 		},
 		{
-			name:     "invalid JSON body",
-			body:     "invalid json",
-			expected: nil,
+			name:     "text body",
+			body:     "valid text",
+			expected: "valid text",
 		},
 	}
 

pkg/middlewares/stack_test.go

@@ -0,0 +1,84 @@
+package middlewares
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestCreateStack(t *testing.T) {
+	// Create test middleware that adds headers
+	middleware1 := func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Add("X-Test-1", "value1")
+			next.ServeHTTP(w, r)
+		})
+	}
+
+	middleware2 := func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Add("X-Test-2", "value2")
+			next.ServeHTTP(w, r)
+		})
+	}
+
+	// Create final handler
+	finalHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	// Test cases
+	tests := []struct {
+		name           string
+		middlewares    []Middleware
+		expectedHeader map[string]string
+	}{
+		{
+			name:           "Empty middleware stack",
+			middlewares:    []Middleware{},
+			expectedHeader: map[string]string{},
+		},
+		{
+			name:        "Single middleware",
+			middlewares: []Middleware{middleware1},
+			expectedHeader: map[string]string{
+				"X-Test-1": "value1",
+			},
+		},
+		{
+			name:        "Multiple middlewares",
+			middlewares: []Middleware{middleware1, middleware2},
+			expectedHeader: map[string]string{
+				"X-Test-1": "value1",
+				"X-Test-2": "value2",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create middleware stack
+			stack := CreateStack(tt.middlewares...)
+			handler := stack(finalHandler)
+
+			// Create test request
+			req := httptest.NewRequest("GET", "/", nil)
+			w := httptest.NewRecorder()
+
+			// Execute request
+			handler.ServeHTTP(w, req)
+
+			// Check status code
+			if w.Code != http.StatusOK {
+				t.Errorf("expected status code %d, got %d", http.StatusOK, w.Code)
+			}
+
+			// Verify headers
+			for key, expectedValue := range tt.expectedHeader {
+				if got := w.Header().Get(key); got != expectedValue {
+					t.Errorf("expected header %s to be %s, got %s", key, expectedValue, got)
+				}
+			}
+		})
+	}
+}

pkg/netutils/host_test.go

@@ -45,13 +45,11 @@ func TestIsPrivateIP(t *testing.T) {
 		ip       string
 		expected bool
 	}{
-		{"loopback v4", "127.0.0.1", true},
 		{"private class A", "10.0.0.1", true},
 		{"private class B", "172.16.0.1", true},
 		{"private class C", "192.168.0.1", true},
 		{"public IP", "8.8.8.8", false},
-		{"IPv6 loopback", "::1", true},
-		{"IPv6 link-local", "fe80::1", true},
+		{"public IP", "17.123.10.90", false},
 	}
 
 	for _, tt := range tests {