Bug: Go Coverage (#20)

* fix ci

* add codecov as orb

* upgrade codecov ver

* fix go routine error

* fix ci error

* fix ci error

Author: 2hmad

.circleci/config.yml

@@ -1,4 +1,8 @@
 version: 2.1
+
+orbs:
+  codecov: codecov/[email protected]
+
 jobs:
   build:
     working_directory: ~/repo

app.go

@@ -1,20 +1,19 @@
 package pulse
 
 import (
-	"errors"
+	"context"
 	"fmt"
 	"github.com/common-nighthawk/go-figure"
 	"net"
 	"net/http"
-	"sync"
+	"time"
 )
 
 type (
 	Pulse struct {
 		config *Config
 		server *http.Server
 		Router *Router
-		mx     sync.Mutex
 	}
 
 	Config struct {
@@ -38,6 +37,7 @@ func New(config ...Config) *Pulse {
 	app := &Pulse{
 		config: &Config{},
 		server: &http.Server{},
+		Router: NewRouter(),
 	}
 
 	if len(config) > 0 {
@@ -55,51 +55,58 @@ func New(config ...Config) *Pulse {
 	return app
 }
 
-func (f *Pulse) Run(address string) {
-	f.mx.Lock()
-	defer f.mx.Unlock()
+func (p *Pulse) Run(address string) {
 	// setup handler
-	handler := RouterHandler(f.Router)
-	f.server.Handler = handler
+	handler := RouterHandler(p.Router)
+	p.server.Handler = handler
 
 	// setup listener
-	listener, err := net.Listen(f.config.Network, address)
+	listener, err := net.Listen(p.config.Network, address)
 	if err != nil {
 		panic(fmt.Errorf("failed to listen: %v", err))
 	}
 
 	// print startup message
-	fmt.Println(f.startupMessage(listener.Addr().String()))
+	fmt.Println(p.startupMessage(listener.Addr().String()))
 
 	// start server
-	err = f.server.Serve(listener)
+	err = p.server.Serve(listener)
 	if err != nil {
 		fmt.Errorf("failed to start server on %s: %v", listener.Addr().String(), err)
 	}
 }
 
-func (f *Pulse) Stop() error {
-	f.mx.Lock()
-	defer f.mx.Unlock()
-
-	if f.server == nil {
-		return errors.New("server not running")
+func (p *Pulse) Stop() error {
+	// Check if the server is already stopped.
+	if p.server == nil {
+		return nil
 	}
-	err := f.server.Shutdown(nil)
+
+	// Disable HTTP keep-alive connections to prevent the server from
+	// accepting any new requests.
+	p.server.SetKeepAlivesEnabled(false)
+
+	// Shutdown the server gracefully to allow existing connections to finish.
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	err := p.server.Shutdown(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to stop server: %v", err)
+		return fmt.Errorf("failed to shut down server: %v", err)
 	}
-	f.server = nil
+
+	// Set the server to a new instance of http.Server to allow starting it again.
+	p.server = &http.Server{}
+
 	return nil
 }
 
-func (f *Pulse) startupMessage(addr string) string {
+func (p *Pulse) startupMessage(addr string) string {
 	myFigure := figure.NewFigure("PULSE", "", true)
 	myFigure.Print()
 
 	var textOne = "=> Server started on <%s>" + "\n"
 	var textTwo = "=> App Name: %s" + "\n"
 	var textThree = "=> Press CTRL+C to stop" + "\n"
 
-	return fmt.Sprintf(textOne, addr) + fmt.Sprintf(textTwo, f.config.AppName) + fmt.Sprintf(textThree)
+	return fmt.Sprintf(textOne, addr) + fmt.Sprintf(textTwo, p.config.AppName) + fmt.Sprintf(textThree)
 }

app_test.go

@@ -71,48 +71,43 @@ func TestRouterHandler2(t *testing.T) {
 	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{},
-	}
+func TestPulse_Run(t *testing.T) {
+	app := New(Config{
+		AppName: "test-app",
+	})
 
-	// Start the server.
-	address := "localhost:9000"
-	go pulse.Run(address)
+	go app.Run(":9090")
 
-	// Wait for the server to start.
-	time.Sleep(100 * time.Millisecond)
+	// Wait for server to start
+	time.Sleep(time.Second)
 
-	// Make a test request to verify that the server is running.
-	req, err := http.NewRequest("GET", "http://"+address, nil)
+	_, err := http.Get("http://localhost:9090/")
 	if err != nil {
-		t.Fatalf("unexpected error creating request: %v", err)
+		t.Errorf("failed to make GET request: %v", err)
 	}
-	respRecorder := httptest.NewRecorder()
-	done := make(chan bool)
-	go func() {
-		pulse.server.Handler.ServeHTTP(respRecorder, req)
-		done <- true
-	}()
-
-	// Wait for the request to complete.
-	<-done
-
-	// Stop the server.
-	err = pulse.Stop()
+
+	err = app.Stop()
 	if err != nil {
-		t.Fatalf("failed to stop server: %v", err)
+		t.Errorf("failed to stop server: %v", err)
 	}
+}
 
-	// Wait for the server to stop.
-	time.Sleep(3 * time.Second)
+func TestPulse_Stop(t *testing.T) {
+	app := New()
+
+	go app.Run(":9090")
+
+	// Wait for server to start
+	time.Sleep(time.Second)
 
-	// Close the test request to ensure that all active connections are closed.
-	err = respRecorder.Result().Body.Close()
+	err := app.Stop()
 	if err != nil {
-		t.Fatalf("failed to close response body: %v", err)
+		t.Errorf("failed to stop server: %v", err)
+	}
+
+	// Make sure server is stopped by attempting to make a GET request
+	_, err = http.Get("http://localhost:9090/")
+	if err == nil {
+		t.Errorf("expected error, got nil")
 	}
 }

context_test.go

@@ -1,7 +1,6 @@
 package pulse
 
 import (
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -100,7 +99,6 @@ func TestContext_Cookie(t *testing.T) {
 
 	// Get the value of the cookie using the GetCookie method.
 	retrievedValue := ctx.GetCookie(cookieName)
-	fmt.Println(retrievedValue)
 	if retrievedValue != cookieValue {
 		t.Errorf("Expected retrieved cookie value to be '%s', but got '%s'", cookieValue, retrievedValue)
 	}