Merge branch 'development' into add-tst-grpc-client

Author: coolwednesday

examples/grpc/grpc-unary-server/main_test.go

@@ -12,51 +12,116 @@ import (
 	"google.golang.org/grpc/credentials/insecure"
 
 	"gofr.dev/examples/grpc/grpc-unary-server/server"
+	"gofr.dev/pkg/gofr/testutil"
 )
 
-func TestGRPCServer(t *testing.T) {
-	client, conn := createGRPCClient(t)
+func TestMain(m *testing.M) {
+	os.Setenv("GOFR_TELEMETRY", "false")
+	m.Run()
+}
+
+func TestIntegration_UnaryServer(t *testing.T) {
+	configs := testutil.NewServerConfigs(t)
+
+	go main()
+	time.Sleep(100 * time.Millisecond) // Giving some time to start the server
+
+	// Create gRPC client connection
+	conn, err := grpc.Dial(configs.GRPCHost, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	require.NoError(t, err, "Failed to connect to unary server")
 	defer conn.Close()
 
+	client := server.NewHelloClient(conn)
+
 	tests := []struct {
-		desc            string
-		request         *server.HelloRequest
-		expectedErr     error
-		responseMessage string
+		desc     string
+		name     string
+		expected string
 	}{
-		{"SayHello with name", &server.HelloRequest{Name: "John"},
-			nil, "Hello John!"},
-		{"SayHello without name", &server.HelloRequest{},
-			nil, "Hello World!"},
-		{"Name exceeding limit", &server.HelloRequest{Name: "This name exceeds the allowed maximum length."},
-			nil, "Hello This name exceeds the allowed maximum length.!"},
+		{"hello with name", "gofr", "Hello gofr!"},
+		{"hello with empty name", "", "Hello World!"},
+		{"hello with special chars", "!@#$%^&*", "Hello !@#$%^&*!"},
+		{"hello with unicode", "你好世界", "Hello 你好世界!"},
+		{"hello with long name", "ThisIsAVeryLongNameThatShouldStillWork", "Hello ThisIsAVeryLongNameThatShouldStillWork!"},
 	}
 
-	for _, tc := range tests {
-		resp, err := client.SayHello(context.Background(), tc.request)
-		require.NoError(t, err)
-		assert.Equal(t, tc.responseMessage, resp.Message)
+	for i, tc := range tests {
+		resp, err := client.SayHello(context.Background(), &server.HelloRequest{
+			Name: tc.name,
+		})
+
+		require.NoError(t, err, "TEST[%d], Failed.\n%s", i, tc.desc)
+		assert.Equal(t, tc.expected, resp.Message, "TEST[%d], Failed.\n%s", i, tc.desc)
 	}
+}
 
-	// case of empty request
-	resp, err := client.SayHello(context.Background(), nil)
-	assert.Equal(t, "Hello World!", resp.Message)
-	require.NoError(t, err)
+func TestIntegration_UnaryServer_Concurrent(t *testing.T) {
+	configs := testutil.NewServerConfigs(t)
 
-	// Test context cancellation
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	_, err = client.SayHello(ctx, &server.HelloRequest{Name: "Test"})
-	assert.Equal(t, "rpc error: code = Canceled desc = context canceled", err.Error())
-}
+	go main()
+	time.Sleep(100 * time.Millisecond) // Giving some time to start the server
+
+	// Create gRPC client connection
+	conn, err := grpc.Dial(configs.GRPCHost, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	require.NoError(t, err, "Failed to connect to unary server")
+	defer conn.Close()
 
-func createGRPCClient(t *testing.T) (server.HelloClient, *grpc.ClientConn) {
-	conn, err := grpc.Dial(":9000", grpc.WithTransportCredentials(insecure.NewCredentials()))
-	if err != nil {
-		t.Errorf("did not connect: %s", err)
+	client := server.NewHelloClient(conn)
+
+	numClients := 5
+	done := make(chan bool, numClients)
+
+	for i := 0; i < numClients; i++ {
+		go func(id int) {
+			resp, err := client.SayHello(context.Background(), &server.HelloRequest{
+				Name: "concurrent client " + string(rune(id)),
+			})
+			require.NoError(t, err, "Concurrent SayHello RPC failed for client %d", id)
+			assert.Contains(t, resp.Message, "concurrent client", "Unexpected response message for concurrent client %d", id)
+			done <- true
+		}(i)
 	}
 
-	return server.NewHelloClient(conn), conn
+	// Wait for all concurrent clients to complete
+	for i := 0; i < numClients; i++ {
+		<-done
+	}
+}
+
+func TestIntegration_UnaryServer_ErrorHandling(t *testing.T) {
+	configs := testutil.NewServerConfigs(t)
+
+	go main()
+	time.Sleep(100 * time.Millisecond) // Giving some time to start the server
+
+	// Create gRPC client connection
+	conn, err := grpc.Dial(configs.GRPCHost, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	require.NoError(t, err, "Failed to connect to unary server")
+	defer conn.Close()
+
+	client := server.NewHelloClient(conn)
+
+	t.Run("ContextCancellation", func(t *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel() // Cancel immediately
+
+		_, err := client.SayHello(ctx, &server.HelloRequest{
+			Name: "cancel test",
+		})
+		assert.Error(t, err, "Context cancellation should return error")
+		assert.Contains(t, err.Error(), "context canceled")
+	})
+
+	t.Run("TimeoutHandling", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond) // Very short timeout
+		defer cancel()
+
+		_, err := client.SayHello(ctx, &server.HelloRequest{
+			Name: "timeout test",
+		})
+		assert.Error(t, err, "Timeout should return error")
+		assert.Contains(t, err.Error(), "context deadline exceeded")
+	})
 }
 
 func TestHelloProtoMethods(t *testing.T) {
@@ -70,12 +135,3 @@ func TestHelloProtoMethods(t *testing.T) {
 	assert.Equal(t, "Hello World", resp.GetMessage())
 	assert.Equal(t, "message:\"Hello World\"", resp.String())
 }
-
-func TestMain(m *testing.M) {
-	os.Setenv("GOFR_TELEMETRY", "false")
-
-	go main()
-	time.Sleep(300 * time.Millisecond) // wait for server to boot
-
-	m.Run()
-}

examples/grpc/grpc-unary-server/server/health_test.go

@@ -0,0 +1,179 @@
+package server
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
+
+	"gofr.dev/pkg/gofr"
+	"gofr.dev/pkg/gofr/container"
+	"gofr.dev/pkg/gofr/testutil"
+)
+
+// createTestContext creates a test gofr.Context
+func createTestContext() *gofr.Context {
+	container := &container.Container{}
+	return &gofr.Context{
+		Context:   context.Background(),
+		Container: container,
+	}
+}
+
+func TestGoFrHealthServer_Creation(t *testing.T) {
+	t.Run("GetOrCreateHealthServer", func(t *testing.T) {
+		// Test GoFr's getOrCreateHealthServer function
+		healthServer := getOrCreateHealthServer()
+		assert.NotNil(t, healthServer, "GoFr health server should not be nil")
+
+		// Test that it implements the GoFr interface (not the standard gRPC interface)
+		// The GoFr health server has different method signatures
+		assert.NotNil(t, healthServer, "Health server should not be nil")
+	})
+
+	t.Run("HealthServerSingleton", func(t *testing.T) {
+		// Test GoFr's singleton pattern for health server
+		healthServer1 := getOrCreateHealthServer()
+		healthServer2 := getOrCreateHealthServer()
+
+		assert.Equal(t, healthServer1, healthServer2, "GoFr health server should be singleton")
+	})
+}
+
+func TestGoFrHealthServer_Methods(t *testing.T) {
+	_ = testutil.NewServerConfigs(t)
+
+	// Test GoFr's health server methods
+	healthServer := getOrCreateHealthServer()
+	ctx := createTestContext()
+
+	t.Run("CheckMethodExists", func(t *testing.T) {
+		// Test that GoFr's Check method exists and accepts correct parameters
+		req := &healthpb.HealthCheckRequest{
+			Service: "test-service",
+		}
+
+		// Test GoFr's Check method signature - this will fail with "unknown service" which is expected
+		resp, err := healthServer.Check(ctx, req)
+		assert.Error(t, err, "Health check should fail for unknown service")
+		assert.Nil(t, resp, "Health check response should be nil for unknown service")
+		assert.Contains(t, err.Error(), "unknown service", "Error should indicate unknown service")
+	})
+
+	t.Run("WatchMethodExists", func(t *testing.T) {
+		// Test that GoFr's Watch method exists and accepts correct parameters
+		req := &healthpb.HealthCheckRequest{
+			Service: "test-service",
+		}
+
+		// Test GoFr's Watch method signature - this will panic with nil stream, but we're testing method existence
+		assert.Panics(t, func() {
+			healthServer.Watch(ctx, req, nil)
+		}, "Watch should panic with nil stream, but method should exist")
+	})
+}
+
+func TestGoFrHealthServer_SetServingStatus(t *testing.T) {
+	_ = testutil.NewServerConfigs(t)
+
+	// Test GoFr's SetServingStatus functionality
+	healthServer := getOrCreateHealthServer()
+	ctx := createTestContext()
+
+	t.Run("SetServingStatus", func(t *testing.T) {
+		// Test GoFr's SetServingStatus method
+		healthServer.SetServingStatus(ctx, "test-service", healthpb.HealthCheckResponse_SERVING)
+
+		// Verify the status was set
+		req := &healthpb.HealthCheckRequest{
+			Service: "test-service",
+		}
+		resp, err := healthServer.Check(ctx, req)
+		require.NoError(t, err, "Health check should not fail")
+		assert.Equal(t, healthpb.HealthCheckResponse_SERVING, resp.Status, "Service should be serving")
+	})
+
+	t.Run("SetNotServingStatus", func(t *testing.T) {
+		// Test GoFr's SetServingStatus with NOT_SERVING
+		healthServer.SetServingStatus(ctx, "test-service-not-serving", healthpb.HealthCheckResponse_NOT_SERVING)
+
+		// Verify the status was set
+		req := &healthpb.HealthCheckRequest{
+			Service: "test-service-not-serving",
+		}
+		resp, err := healthServer.Check(ctx, req)
+		require.NoError(t, err, "Health check should not fail")
+		assert.Equal(t, healthpb.HealthCheckResponse_NOT_SERVING, resp.Status, "Service should not be serving")
+	})
+}
+
+func TestGoFrHealthServer_Shutdown(t *testing.T) {
+	_ = testutil.NewServerConfigs(t)
+
+	// Test GoFr's Shutdown functionality
+	healthServer := getOrCreateHealthServer()
+	ctx := createTestContext()
+
+	t.Run("Shutdown", func(t *testing.T) {
+		// Test GoFr's Shutdown method
+		healthServer.Shutdown(ctx)
+
+		// After shutdown, all services should return NOT_SERVING
+		req := &healthpb.HealthCheckRequest{
+			Service: "any-service",
+		}
+		resp, err := healthServer.Check(ctx, req)
+		// After shutdown, health checks should fail with "unknown service"
+		assert.Error(t, err, "Health check should fail after shutdown")
+		assert.Nil(t, resp, "Health check response should be nil after shutdown")
+		assert.Contains(t, err.Error(), "unknown service", "Error should indicate unknown service after shutdown")
+	})
+}
+
+func TestGoFrHealthServer_Resume(t *testing.T) {
+	_ = testutil.NewServerConfigs(t)
+
+	// Test GoFr's Resume functionality
+	healthServer := getOrCreateHealthServer()
+	ctx := createTestContext()
+
+	t.Run("Resume", func(t *testing.T) {
+		// Test GoFr's Resume method
+		healthServer.Resume(ctx)
+
+		// After resume, services should return to their previous status
+		healthServer.SetServingStatus(ctx, "test-service-resume", healthpb.HealthCheckResponse_SERVING)
+
+		req := &healthpb.HealthCheckRequest{
+			Service: "test-service-resume",
+		}
+		resp, err := healthServer.Check(ctx, req)
+		require.NoError(t, err, "Health check should not fail")
+		assert.Equal(t, healthpb.HealthCheckResponse_SERVING, resp.Status, "Service should be serving after resume")
+	})
+}
+
+func TestGoFrHealthServer_MultipleInstances(t *testing.T) {
+	_ = testutil.NewServerConfigs(t)
+
+	// Test GoFr's singleton pattern
+	t.Run("SingletonPattern", func(t *testing.T) {
+		healthServer1 := getOrCreateHealthServer()
+		healthServer2 := getOrCreateHealthServer()
+		ctx := createTestContext()
+
+		assert.Equal(t, healthServer1, healthServer2, "GoFr health server should be singleton")
+
+		// Test that operations on one affect the other
+		healthServer1.SetServingStatus(ctx, "singleton-test", healthpb.HealthCheckResponse_SERVING)
+
+		req := &healthpb.HealthCheckRequest{
+			Service: "singleton-test",
+		}
+		resp, err := healthServer2.Check(ctx, req)
+		require.NoError(t, err, "Health check should not fail")
+		assert.Equal(t, healthpb.HealthCheckResponse_SERVING, resp.Status, "Singleton should share state")
+	})
+}