Add more test cases

Signed-off-by: Hiroshi Hatake <[email protected]>

Author: cosmo0920

config_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"os"
 	"testing"
 	"time"
 
@@ -129,6 +130,63 @@ func Test_loadConfig_ModeServer(t *testing.T) {
 	})
 }
 
+func Test_loadConfig_InvalidValues(t *testing.T) {
+    // Test for a bad duration value
+	t.Run("server mode with invalid reload_interval logs warning and uses default", func(t *testing.T) {
+		fbit := &plugin.Fluentbit{
+			Logger: newTestLogger(t),
+			Conf: mapConfigLoader{
+				"mode":                    "server",
+				"server.endpoint":         "jaeger-collector:14250",
+				"server.service_names":    "service1",
+				"server.reload_interval":  "5minutes", // Invalid format
+			},
+		}
+		cfg, err := loadConfig(fbit)
+		assert.NoError(t, err)
+		assert.Equal(t, 5*time.Minute, cfg.ServerReloadInterval)
+	})
+
+	t.Run("server mode with both endpoint and strategy_file should fail", func(t *testing.T) {
+		fbit := &plugin.Fluentbit{
+			Logger: newTestLogger(t),
+			Conf: mapConfigLoader{
+				"mode":                 "server",
+				"server.endpoint":      "jaeger-collector:14250",
+				"server.strategy_file": "/path/to/file.json",
+			},
+		}
+		_, err := loadConfig(fbit)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "are mutually exclusive")
+	})
+}
+
+func Test_loadTLSConfig_FileErrors(t *testing.T) {
+    // Test for a non-existent CA file
+    t.Run("should fail with non-existent CA file", func(t *testing.T) {
+        cfg := TLSSettings{CAFile: "/tmp/this-file-does-not-exist.ca"}
+        _, err := loadTLSConfig(cfg)
+        assert.Error(t, err)
+    })
+
+    // Test for a bad key pair
+	t.Run("should fail with invalid cert/key pair", func(t *testing.T) {
+		// Create dummy (but invalid) files
+		certFile, _ := os.CreateTemp("", "cert")
+		defer os.Remove(certFile.Name())
+		keyFile, _ := os.CreateTemp("", "key")
+		defer os.Remove(keyFile.Name())
+
+		certFile.WriteString("not a cert")
+		keyFile.WriteString("not a key")
+
+		cfg := TLSSettings{CertFile: certFile.Name(), KeyFile: keyFile.Name()}
+		_, err := loadTLSConfig(cfg)
+		assert.Error(t, err)
+	})
+}
+
 func Test_loadConfig_CORS(t *testing.T) {
 	testCases := []struct {
 		name            string

jaeger_services_test.go

@@ -139,6 +139,39 @@ func Test_InitServer_FileStrategy(t *testing.T) {
 	})
 }
 
+func Test_InitServer_FileStrategyErrors(t *testing.T) {
+	t.Run("fails when strategy file does not exist", func(t *testing.T) {
+		fbit := &plugin.Fluentbit{
+			Logger: newTestLogger(t),
+			Conf:   mapConfigLoader{"mode": "server", "server.strategy_file": "/tmp/non-existent-file.json"},
+		}
+		plug := &jaegerRemotePlugin{}
+		err := plug.Init(context.Background(), fbit)
+		assert.Error(t, err)
+	})
+
+	t.Run("fails when strategy file contains invalid json", func(t *testing.T) {
+		tmpFile, err := os.CreateTemp("", "strategy-*.json")
+		assert.NoError(t, err)
+		defer os.Remove(tmpFile.Name())
+		_, err = tmpFile.Write([]byte(`{ "invalid-json`))
+		assert.NoError(t, err)
+		tmpFile.Close()
+
+		fbit := &plugin.Fluentbit{
+			Logger: newTestLogger(t),
+			Conf: mapConfigLoader{
+				"mode":                 "server",
+				"server.strategy_file": tmpFile.Name(),
+			},
+		}
+		plug := &jaegerRemotePlugin{}
+		err = plug.Init(context.Background(), fbit)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "could not unmarshal")
+	})
+}
+
 func Test_InitClient(t *testing.T) {
 	t.Run("successfully initializes in client mode", func(t *testing.T) {
 		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -258,6 +291,105 @@ func Test_InitServer_EndToEnd(t *testing.T) {
 	}
 }
 
+/* Helper function to mock sampling manager client */
+
+type mockSamplingClient struct {
+	api_v2.SamplingManagerClient
+	GetSamplingStrategyFunc func(ctx context.Context, in *api_v2.SamplingStrategyParameters, opts ...grpc.CallOption) (*api_v2.SamplingStrategyResponse, error)
+}
+
+func (m *mockSamplingClient) GetSamplingStrategy(ctx context.Context, in *api_v2.SamplingStrategyParameters, opts ...grpc.CallOption) (*api_v2.SamplingStrategyResponse, error) {
+	if m.GetSamplingStrategyFunc != nil {
+		return m.GetSamplingStrategyFunc(ctx, in, opts...)
+	}
+	return nil, status.Error(codes.Unimplemented, "method GetSamplingStrategy not implemented")
+}
+
+func Test_getAndCacheStrategy_Retry(t *testing.T) {
+	t.Run("should retry on failure and eventually succeed", func(t *testing.T) {
+		var callCount int
+		mockSuccessStrategy := &api_v2.SamplingStrategyResponse{StrategyType: api_v2.SamplingStrategyType_PROBABILISTIC}
+		mockErr := status.Error(codes.Unavailable, "server not ready")
+
+		mockClient := &mockSamplingClient{
+			GetSamplingStrategyFunc: func(ctx context.Context, in *api_v2.SamplingStrategyParameters, opts ...grpc.CallOption) (*api_v2.SamplingStrategyResponse, error) {
+				callCount++
+				if callCount > 2 {
+					return mockSuccessStrategy, nil
+				}
+				return nil, mockErr
+			},
+		}
+
+		plug := &jaegerRemotePlugin{
+			log: newTestLogger(t),
+			config: &Config{
+				ServerRetry: &RetryConfig{
+					InitialInterval: 10 * time.Millisecond,
+					MaxInterval:     100 * time.Millisecond,
+					Multiplier:      1.5,
+					MaxRetry:        5,
+				},
+			},
+			server: &serverComponent{
+				cache: &samplingStrategyCache{
+					strategies: make(map[string]*cacheEntry),
+				},
+				sampler: &remoteSampler{
+					client: mockClient,
+				},
+			},
+		}
+
+		strategy, err := plug.getAndCacheStrategy(context.Background(), "test-service")
+
+		assert.NoError(t, err)
+		assert.NotZero(t, strategy)
+		assert.Equal(t, mockSuccessStrategy, strategy)
+		assert.Equal(t, 3, callCount, "Expected the client to be called 3 times (2 failures, 1 success)")
+	})
+
+	t.Run("should stop retrying if context is cancelled", func(t *testing.T) {
+		mockErr := status.Error(codes.Unavailable, "server not ready")
+		mockClient := &mockSamplingClient{
+			GetSamplingStrategyFunc: func(ctx context.Context, in *api_v2.SamplingStrategyParameters, opts ...grpc.CallOption) (*api_v2.SamplingStrategyResponse, error) {
+				return nil, mockErr
+			},
+		}
+
+		plug := &jaegerRemotePlugin{
+			log: newTestLogger(t),
+			config: &Config{
+				ServerRetry: &RetryConfig{
+					InitialInterval: 50 * time.Millisecond,
+					MaxInterval:     200 * time.Millisecond,
+					Multiplier:      1.5,
+					MaxRetry:        10,
+				},
+			},
+			server: &serverComponent{
+				cache: &samplingStrategyCache{
+					strategies: make(map[string]*cacheEntry),
+				},
+				sampler: &remoteSampler{
+					client: mockClient,
+				},
+			},
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+
+		go func() {
+			time.Sleep(20 * time.Millisecond)
+			cancel()
+		}()
+
+		_, err := plug.getAndCacheStrategy(ctx, "test-service")
+
+		assert.Error(t, err)
+	})
+}
+
 func Test_InitServer_Failure(t *testing.T) {
 	t.Run("fails if both http and grpc listen addresses are missing", func(t *testing.T) {
 		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
@@ -440,6 +572,22 @@ func Test_ServerHandlers(t *testing.T) {
 
 		assert.Equal(t, http.StatusNotFound, rr.Code)
 	})
+
+	t.Run("HTTP handler returns 400 Bad Request for missing service", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "/sampling", nil) // No service param
+		rr := httptest.NewRecorder()
+		plug.handleSampling(rr, req)
+		assert.Equal(t, http.StatusBadRequest, rr.Code)
+	})
+
+	t.Run("gRPC handler returns InvalidArgument for missing service name", func(t *testing.T) {
+		s := &grpcApiServer{plug: plug}
+		params := &api_v2.SamplingStrategyParameters{ServiceName: ""} // Empty service name
+		_, err := s.GetSamplingStrategy(context.Background(), params)
+		st, ok := status.FromError(err)
+		assert.True(t, ok)
+		assert.Equal(t, codes.InvalidArgument, st.Code())
+	})
 }
 
 func getFreePort(t *testing.T) string {