Merge pull request #62 from KianYang-Lee/improvement/server-test-refa…

…ctor

Improve readability for server_test

server/server_test.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"testing"
 	"time"
@@ -70,55 +71,83 @@ func TestServer_WithBaseContext(t *testing.T) {
 	}
 }
 
-func TestServer_Run(t *testing.T) {
-	// Create a new Server instance
-	server := NewServer(":0")
-
-	channel := mocks.NewMockChannel(t)
-	channel.EXPECT().Path().Return("/test")
-	channel.EXPECT().Handler().Return(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
+func TestServer_WithReadinessChan(t *testing.T) {
+	// Create a new Server instance with a base context
+	ready := make(chan struct{})
+	server := NewServer(":0", WithReadinessChan(ready))
 
-	server.AddChannel(channel)
+	if server.ready == nil {
+		t.Error("Expected non-nil channel")
+	}
 
-	done := make(chan struct{})
+	close(server.ready)
+	_, ok := <-ready
+	if ok {
+		t.Error("Expected closed channel")
+	}
+}
 
-	// Run the server
-	for i := 0; i < 2; i++ {
-		go func() {
-			err := server.Run()
-			switch err {
-			case nil:
-				close(done)
-			case ErrServerAlreadyRunning:
-				done <- struct{}{}
-			default:
-				t.Errorf("Got unexpected error: %v", err)
+func TestServer_Run(t *testing.T) {
+	noOfReruns := []int{0, 1, 2}
+
+	for _, run := range noOfReruns {
+		t.Run(fmt.Sprintf("%d times of calling Run", run), func(t *testing.T) {
+			// Create a new Server instance
+			ready := make(chan struct{})
+			server := NewServer(":0", WithReadinessChan(ready))
+
+			channel := mocks.NewMockChannel(t)
+			channel.EXPECT().Path().Return("/test")
+			channel.EXPECT().Handler().Return(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
+
+			server.AddChannel(channel)
+
+			// for signaling server stopped without error
+			done := make(chan struct{})
+
+			// Run the server
+			go func() {
+				err := server.Run()
+				switch err {
+				case nil:
+					close(done)
+				default:
+					t.Errorf("Got unexpected error: %v", err)
+				}
+			}()
+
+			// Wait for server to be ready
+			select {
+			case <-ready:
+			case <-time.After(1 * time.Second):
+				t.Error("Expected server to start")
 			}
-		}()
-	}
 
-	select {
-	case _, ok := <-done:
-		if !ok {
-			t.Error("Expected server to start")
-		}
-	case <-time.After(1 * time.Second):
-		t.Error("Expected server to start")
-	}
+			// Test that calling Run on a running server returns
+			// ErrServerAlreadyRunning
+			for i := 0; i < run; i++ {
+				if err := server.Run(); err != ErrServerAlreadyRunning {
+					t.Error("Should return ErrServerAlreadyRunning when triggered run on running server")
+				}
+			}
 
-	if err := server.handler.Close(); err != nil {
-		t.Errorf("Expected no error, but got %v", err)
-	}
+			if err := server.handler.Close(); err != nil {
+				t.Errorf("Expected no error, but got %v", err)
+			}
 
-	select {
-	case <-done:
-	case <-time.After(1 * time.Second):
-		t.Error("Expected server to stop")
+			select {
+			case <-done:
+			case <-time.After(1 * time.Second):
+				t.Error("Expected server to stop")
+			}
+		})
 	}
 }
+
 func TestServer_Close(t *testing.T) {
 	// Create a new Server instance
-	server := NewServer(":0")
+	ready := make(chan struct{})
+	server := NewServer(":0", WithReadinessChan(ready))
 
 	// Create a context with a timeout
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -137,27 +166,19 @@ func TestServer_Close(t *testing.T) {
 	done := make(chan struct{})
 
 	// Run the server
-	for i := 0; i < 2; i++ {
-		go func() {
-			err := server.Run()
-			switch err {
-			case nil:
-				close(done)
-			case ErrServerAlreadyRunning:
-				done <- struct{}{}
-			default:
-				t.Errorf("Got unexpected error: %v", err)
-			}
-		}()
-	}
+	go func() {
+		err := server.Run()
+		switch err {
+		case nil:
+			close(done)
+		default:
+			t.Errorf("Got unexpected error: %v", err)
+		}
+	}()
 
 	select {
-	case _, ok := <-done:
-		if !ok {
-			t.Error("Expected server to start")
-		}
+	case <-ready:
 	case <-time.After(1 * time.Second):
-		t.Error("Expected server to start")
 	}
 
 	// Call the Shutdown method
@@ -175,7 +196,8 @@ func TestServer_Close(t *testing.T) {
 
 func TestServer_Close_NoContext(t *testing.T) {
 	// Create a new Server instance
-	server := NewServer(":0")
+	ready := make(chan struct{})
+	server := NewServer(":0", WithReadinessChan(ready))
 
 	// Create a mock channel
 	channel := mocks.NewMockChannel(t)
@@ -189,25 +211,18 @@ func TestServer_Close_NoContext(t *testing.T) {
 	done := make(chan struct{})
 
 	// Run the server
-	for i := 0; i < 2; i++ {
-		go func() {
-			err := server.Run()
-			switch err {
-			case nil:
-				close(done)
-			case ErrServerAlreadyRunning:
-				done <- struct{}{}
-			default:
-				t.Errorf("Got unexpected error: %v", err)
-			}
-		}()
-	}
+	go func() {
+		err := server.Run()
+		switch err {
+		case nil:
+			close(done)
+		default:
+			t.Errorf("Got unexpected error: %v", err)
+		}
+	}()
 
 	select {
-	case _, ok := <-done:
-		if !ok {
-			t.Error("Expected server to start")
-		}
+	case <-ready:
 	case <-time.After(1 * time.Second):
 		t.Error("Expected server to start")
 	}
@@ -228,6 +243,7 @@ func TestServer_Close_NoContext(t *testing.T) {
 func TestServer_Addr(t *testing.T) {
 	// Create a new Server instance
 	done := make(chan struct{})
+
 	server := NewServer(":0", WithReadinessChan(done))
 
 	defer server.Close()