From c786033b39d31c3544f10ab6700200d44c64186a Mon Sep 17 00:00:00 2001 From: Milad Date: Wed, 19 Nov 2025 12:46:51 +0330 Subject: [PATCH 1/2] test(ginS): add comprehensive test coverage for ginS package Improve test coverage for ginS package by adding 18 test functions covering HTTP methods, routing, middleware, static files, and templates. --- ginS/gins_test.go | 246 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 ginS/gins_test.go diff --git a/ginS/gins_test.go b/ginS/gins_test.go new file mode 100644 index 00000000..6c7cad4d --- /dev/null +++ b/ginS/gins_test.go @@ -0,0 +1,246 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package ginS + +import ( + "html/template" + "net/http" + "net/http/httptest" + "testing" + + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" +) + +func init() { + gin.SetMode(gin.TestMode) +} + +func TestGET(t *testing.T) { + GET("/test", func(c *gin.Context) { + c.String(http.StatusOK, "test") + }) + + req := httptest.NewRequest("GET", "/test", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "test", w.Body.String()) +} + +func TestPOST(t *testing.T) { + POST("/post", func(c *gin.Context) { + c.String(http.StatusCreated, "created") + }) + + req := httptest.NewRequest("POST", "/post", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusCreated, w.Code) + assert.Equal(t, "created", w.Body.String()) +} + +func TestPUT(t *testing.T) { + PUT("/put", func(c *gin.Context) { + c.String(http.StatusOK, "updated") + }) + + req := httptest.NewRequest("PUT", "/put", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "updated", w.Body.String()) +} + +func TestDELETE(t *testing.T) { + DELETE("/delete", func(c *gin.Context) { + c.String(http.StatusOK, "deleted") + }) + + req := httptest.NewRequest("DELETE", "/delete", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "deleted", w.Body.String()) +} + +func TestPATCH(t *testing.T) { + PATCH("/patch", func(c *gin.Context) { + c.String(http.StatusOK, "patched") + }) + + req := httptest.NewRequest("PATCH", "/patch", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "patched", w.Body.String()) +} + +func TestOPTIONS(t *testing.T) { + OPTIONS("/options", func(c *gin.Context) { + c.String(http.StatusOK, "options") + }) + + req := httptest.NewRequest("OPTIONS", "/options", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "options", w.Body.String()) +} + +func TestHEAD(t *testing.T) { + HEAD("/head", func(c *gin.Context) { + c.String(http.StatusOK, "head") + }) + + req := httptest.NewRequest("HEAD", "/head", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +func TestAny(t *testing.T) { + Any("/any", func(c *gin.Context) { + c.String(http.StatusOK, "any") + }) + + req := httptest.NewRequest("GET", "/any", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "any", w.Body.String()) +} + +func TestHandle(t *testing.T) { + Handle("GET", "/handle", func(c *gin.Context) { + c.String(http.StatusOK, "handle") + }) + + req := httptest.NewRequest("GET", "/handle", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "handle", w.Body.String()) +} + +func TestGroup(t *testing.T) { + group := Group("/group") + group.GET("/test", func(c *gin.Context) { + c.String(http.StatusOK, "group test") + }) + + req := httptest.NewRequest("GET", "/group/test", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) + assert.Equal(t, "group test", w.Body.String()) +} + +func TestUse(t *testing.T) { + var middlewareExecuted bool + Use(func(c *gin.Context) { + middlewareExecuted = true + c.Next() + }) + + GET("/middleware-test", func(c *gin.Context) { + c.String(http.StatusOK, "ok") + }) + + req := httptest.NewRequest("GET", "/middleware-test", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.True(t, middlewareExecuted) + assert.Equal(t, http.StatusOK, w.Code) +} + +func TestNoRoute(t *testing.T) { + NoRoute(func(c *gin.Context) { + c.String(http.StatusNotFound, "custom 404") + }) + + req := httptest.NewRequest("GET", "/nonexistent", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusNotFound, w.Code) + assert.Equal(t, "custom 404", w.Body.String()) +} + +func TestNoMethod(t *testing.T) { + NoMethod(func(c *gin.Context) { + c.String(http.StatusMethodNotAllowed, "method not allowed") + }) + + // This just verifies that NoMethod is callable + // Testing the actual behavior would require a separate engine instance + assert.NotNil(t, engine()) +} + +func TestRoutes(t *testing.T) { + GET("/routes-test", func(c *gin.Context) {}) + + routes := Routes() + assert.NotEmpty(t, routes) + + found := false + for _, route := range routes { + if route.Path == "/routes-test" && route.Method == "GET" { + found = true + break + } + } + assert.True(t, found) +} + +func TestSetHTMLTemplate(t *testing.T) { + tmpl := template.Must(template.New("test").Parse("Hello {{.}}")) + SetHTMLTemplate(tmpl) + + // Verify engine has template set + assert.NotNil(t, engine()) +} + +func TestStaticFile(t *testing.T) { + StaticFile("/static-file", "../testdata/test_file.txt") + + req := httptest.NewRequest("GET", "/static-file", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +func TestStatic(t *testing.T) { + Static("/static-dir", "../testdata") + + req := httptest.NewRequest("GET", "/static-dir/test_file.txt", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} + +func TestStaticFS(t *testing.T) { + fs := http.Dir("../testdata") + StaticFS("/static-fs", fs) + + req := httptest.NewRequest("GET", "/static-fs/test_file.txt", nil) + w := httptest.NewRecorder() + engine().ServeHTTP(w, req) + + assert.Equal(t, http.StatusOK, w.Code) +} From 0f3213e3c3a8cd1ad20334da57e3e7e202705281 Mon Sep 17 00:00:00 2001 From: Milad Date: Mon, 24 Nov 2025 15:33:58 +0330 Subject: [PATCH 2/2] use http.Method* constants instead of raw strings in gins_test.go --- ginS/gins_test.go | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/ginS/gins_test.go b/ginS/gins_test.go index 6c7cad4d..14a22de2 100644 --- a/ginS/gins_test.go +++ b/ginS/gins_test.go @@ -23,7 +23,7 @@ func TestGET(t *testing.T) { c.String(http.StatusOK, "test") }) - req := httptest.NewRequest("GET", "/test", nil) + req := httptest.NewRequest(http.MethodGet, "/test", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -36,7 +36,7 @@ func TestPOST(t *testing.T) { c.String(http.StatusCreated, "created") }) - req := httptest.NewRequest("POST", "/post", nil) + req := httptest.NewRequest(http.MethodPost, "/post", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -49,7 +49,7 @@ func TestPUT(t *testing.T) { c.String(http.StatusOK, "updated") }) - req := httptest.NewRequest("PUT", "/put", nil) + req := httptest.NewRequest(http.MethodPut, "/put", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -62,7 +62,7 @@ func TestDELETE(t *testing.T) { c.String(http.StatusOK, "deleted") }) - req := httptest.NewRequest("DELETE", "/delete", nil) + req := httptest.NewRequest(http.MethodDelete, "/delete", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -75,7 +75,7 @@ func TestPATCH(t *testing.T) { c.String(http.StatusOK, "patched") }) - req := httptest.NewRequest("PATCH", "/patch", nil) + req := httptest.NewRequest(http.MethodPatch, "/patch", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -88,7 +88,7 @@ func TestOPTIONS(t *testing.T) { c.String(http.StatusOK, "options") }) - req := httptest.NewRequest("OPTIONS", "/options", nil) + req := httptest.NewRequest(http.MethodOptions, "/options", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -101,7 +101,7 @@ func TestHEAD(t *testing.T) { c.String(http.StatusOK, "head") }) - req := httptest.NewRequest("HEAD", "/head", nil) + req := httptest.NewRequest(http.MethodHead, "/head", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -113,7 +113,7 @@ func TestAny(t *testing.T) { c.String(http.StatusOK, "any") }) - req := httptest.NewRequest("GET", "/any", nil) + req := httptest.NewRequest(http.MethodGet, "/any", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -122,11 +122,11 @@ func TestAny(t *testing.T) { } func TestHandle(t *testing.T) { - Handle("GET", "/handle", func(c *gin.Context) { + Handle(http.MethodGet, "/handle", func(c *gin.Context) { c.String(http.StatusOK, "handle") }) - req := httptest.NewRequest("GET", "/handle", nil) + req := httptest.NewRequest(http.MethodGet, "/handle", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -140,7 +140,7 @@ func TestGroup(t *testing.T) { c.String(http.StatusOK, "group test") }) - req := httptest.NewRequest("GET", "/group/test", nil) + req := httptest.NewRequest(http.MethodGet, "/group/test", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -159,7 +159,7 @@ func TestUse(t *testing.T) { c.String(http.StatusOK, "ok") }) - req := httptest.NewRequest("GET", "/middleware-test", nil) + req := httptest.NewRequest(http.MethodGet, "/middleware-test", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -172,7 +172,7 @@ func TestNoRoute(t *testing.T) { c.String(http.StatusNotFound, "custom 404") }) - req := httptest.NewRequest("GET", "/nonexistent", nil) + req := httptest.NewRequest(http.MethodGet, "/nonexistent", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -198,7 +198,7 @@ func TestRoutes(t *testing.T) { found := false for _, route := range routes { - if route.Path == "/routes-test" && route.Method == "GET" { + if route.Path == "/routes-test" && route.Method == http.MethodGet { found = true break } @@ -217,7 +217,7 @@ func TestSetHTMLTemplate(t *testing.T) { func TestStaticFile(t *testing.T) { StaticFile("/static-file", "../testdata/test_file.txt") - req := httptest.NewRequest("GET", "/static-file", nil) + req := httptest.NewRequest(http.MethodGet, "/static-file", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -227,7 +227,7 @@ func TestStaticFile(t *testing.T) { func TestStatic(t *testing.T) { Static("/static-dir", "../testdata") - req := httptest.NewRequest("GET", "/static-dir/test_file.txt", nil) + req := httptest.NewRequest(http.MethodGet, "/static-dir/test_file.txt", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req) @@ -238,7 +238,7 @@ func TestStaticFS(t *testing.T) { fs := http.Dir("../testdata") StaticFS("/static-fs", fs) - req := httptest.NewRequest("GET", "/static-fs/test_file.txt", nil) + req := httptest.NewRequest(http.MethodGet, "/static-fs/test_file.txt", nil) w := httptest.NewRecorder() engine().ServeHTTP(w, req)