Updates: Add test env (#19)

* add tests files

* remove flag

* handle errors

* fix set & get cookies method

* fix ci error

Author: 2hmad

.github/workflows/codecov.yml

@@ -31,4 +31,3 @@ jobs:
         uses: codecov/codecov-action@v3
         with:
           working-directory: main
-          flags: unittests

app.go

@@ -1,6 +1,7 @@
 package pulse
 
 import (
+	"errors"
 	"fmt"
 	"github.com/common-nighthawk/go-figure"
 	"net"
@@ -68,15 +69,20 @@ func (f *Pulse) Run(address string) {
 	// start server
 	err = f.server.Serve(listener)
 	if err != nil {
-		panic(fmt.Errorf("failed to serve: %v", err))
+		fmt.Errorf("failed to start server on %s: %v", listener.Addr().String(), err)
 	}
 }
 
-func (f *Pulse) Stop() {
+func (f *Pulse) Stop() error {
+	if f.server == nil {
+		return errors.New("server not running")
+	}
 	err := f.server.Shutdown(nil)
 	if err != nil {
-		return
+		return fmt.Errorf("failed to stop server: %v", err)
 	}
+	f.server = nil
+	return nil
 }
 
 func (f *Pulse) startupMessage(addr string) string {

app_test.go

@@ -1,9 +1,110 @@
 package pulse
 
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
 var app *Pulse
 
 func init() {
 	app = New(Config{
 		AppName: "Test App",
 	})
 }
+
+func TestNew(t *testing.T) {
+	app := New()
+	if app.config.AppName != DefaultAppName {
+		t.Errorf("AppName: expected %q, actual %q", DefaultAppName, app.config.AppName)
+	}
+	if app.config.Network != DefaultNetwork {
+		t.Errorf("Network: expected %q, actual %q", DefaultNetwork, app.config.Network)
+	}
+
+	// Test New() function with custom config
+	app = New(Config{
+		AppName: "Test App",
+		Network: "udp",
+	})
+	if app.config.AppName != "Test App" {
+		t.Errorf("AppName: expected %q, actual %q", "Test App", app.config.AppName)
+	}
+	if app.config.Network != "udp" {
+		t.Errorf("Network: expected %q, actual %q", "udp", app.config.Network)
+	}
+}
+
+func TestPulse_startupMessage(t *testing.T) {
+	app := New(Config{
+		AppName: "Test App",
+	})
+
+	addr := "localhost:8080"
+	expected := "=> Server started on <" + addr + ">\n" +
+		"=> App Name: " + app.config.AppName + "\n" +
+		"=> Press CTRL+C to stop\n"
+	actual := app.startupMessage(addr)
+
+	if actual != expected {
+		t.Errorf("startupMessage: expected %q, actual %q", expected, actual)
+	}
+}
+
+func TestRouterHandler2(t *testing.T) {
+	router := NewRouter()
+	router.Get("/", func(ctx *Context) error {
+		ctx.String("Hello, World!")
+		return nil
+	})
+
+	handler := RouterHandler(router)
+
+	req, err := http.NewRequest("GET", "/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+}
+
+func TestPulse_Run_Stop(t *testing.T) {
+	// Create a new Pulse instance.
+	pulse := &Pulse{
+		Router: NewRouter(),
+		config: &Config{Network: "tcp"},
+		server: &http.Server{},
+	}
+
+	// Start the server.
+	address := "localhost:9000"
+	go pulse.Run(address)
+
+	// Wait for the server to start.
+	time.Sleep(100 * time.Millisecond)
+
+	// Make a test request to verify that the server is running.
+	req, err := http.NewRequest("GET", "http://"+address, nil)
+	if err != nil {
+		t.Fatalf("unexpected error creating request: %v", err)
+	}
+	respRecorder := httptest.NewRecorder()
+	pulse.server.Handler.ServeHTTP(respRecorder, req)
+
+	err = pulse.Stop()
+	if err != nil {
+		t.Fatalf("failed to stop server: %v", err)
+	}
+
+	// Wait for the server to stop.
+	time.Sleep(3 * time.Second)
+
+	// Close the test request to ensure that all active connections are closed.
+	err = respRecorder.Result().Body.Close()
+	if err != nil {
+		t.Fatalf("failed to close response body: %v", err)
+	}
+}

constants/routingSigns_test.go

@@ -0,0 +1,24 @@
+package constants
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestConstants(t *testing.T) {
+	expected := map[string]string{
+		"WildcardSign": WildcardSign,
+		"ParamSign":    ParamSign,
+		"OptionalSign": OptionalSign,
+	}
+
+	actual := map[string]string{
+		"WildcardSign": "*",
+		"ParamSign":    ":",
+		"OptionalSign": "?",
+	}
+
+	if !reflect.DeepEqual(expected, actual) {
+		t.Errorf("Expected %v, but got %v", expected, actual)
+	}
+}

context.go

@@ -11,6 +11,7 @@ type handlerFunc func(ctx *Context) error
 
 type Context struct {
 	ResponseWriter http.ResponseWriter
+	Response       http.Response
 	Request        *http.Request
 	Params         map[string]string
 	paramValues    []string
@@ -113,15 +114,28 @@ func (c *Context) SetCookie(cookie *Cookie) {
 		HttpOnly: cookie.HTTPOnly,
 		SameSite: cookie.SameSite,
 	})
+
+	c.Cookies = append(c.Cookies, &http.Cookie{
+		Name:     cookie.Name,
+		Value:    cookie.Value,
+		Path:     cookie.Path,
+		Domain:   cookie.Domain,
+		Expires:  cookie.Expires,
+		MaxAge:   cookie.MaxAge,
+		Secure:   cookie.Secure,
+		HttpOnly: cookie.HTTPOnly,
+		SameSite: cookie.SameSite,
+	})
 }
 
 // GetCookie returns the value of the cookie with the given name.
 func (c *Context) GetCookie(name string) string {
-	cookie, err := c.Request.Cookie(name)
-	if err != nil {
-		return ""
+	for _, cookie := range c.Cookies {
+		if cookie.Name == name {
+			return cookie.Value
+		}
 	}
-	return cookie.Value
+	return ""
 }
 
 // ClearCookie deletes the cookie with the given name.