refactor zrpc server interceptor builder (#4300)

zrpc/server_test.go

@@ -1,6 +1,7 @@
 package zrpc
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -16,47 +17,6 @@ import (
 	"google.golang.org/grpc"
 )
 
-func TestServer_setupInterceptors(t *testing.T) {
-	rds, err := miniredis.Run()
-	assert.NoError(t, err)
-	defer rds.Close()
-
-	server := new(mockedServer)
-	conf := RpcServerConf{
-		Auth: true,
-		Redis: redis.RedisKeyConf{
-			RedisConf: redis.RedisConf{
-				Host: rds.Addr(),
-				Type: redis.NodeType,
-			},
-			Key: "foo",
-		},
-		CpuThreshold: 10,
-		Timeout:      100,
-		Middlewares: ServerMiddlewaresConf{
-			Trace:      true,
-			Recover:    true,
-			Stat:       true,
-			Prometheus: true,
-			Breaker:    true,
-		},
-		MethodTimeouts: []MethodTimeoutConf{
-			{
-				FullMethod: "/foo",
-				Timeout:    5 * time.Second,
-			},
-		},
-	}
-	err = setupInterceptors(server, conf, new(stat.Metrics))
-	assert.Nil(t, err)
-	assert.Equal(t, 3, len(server.unaryInterceptors))
-	assert.Equal(t, 1, len(server.streamInterceptors))
-
-	rds.SetError("mock error")
-	err = setupInterceptors(server, conf, new(stat.Metrics))
-	assert.Error(t, err)
-}
-
 func TestServer(t *testing.T) {
 	DontLogContentForMethod("foo")
 	SetServerSlowThreshold(time.Second)
@@ -198,3 +158,153 @@ func (m *mockedServer) SetName(_ string) {
 func (m *mockedServer) Start(_ internal.RegisterFn) error {
 	return nil
 }
+
+func Test_setupUnaryInterceptors(t *testing.T) {
+	tests := []struct {
+		name string
+		r    *mockedServer
+		conf RpcServerConf
+		len  int
+	}{
+		{
+			name: "empty",
+			r:    &mockedServer{},
+			len:  0,
+		},
+		{
+			name: "custom",
+			r: &mockedServer{
+				unaryInterceptors: []grpc.UnaryServerInterceptor{
+					func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo,
+						handler grpc.UnaryHandler) (interface{}, error) {
+						return nil, nil
+					},
+				},
+			},
+			len: 1,
+		},
+		{
+			name: "middleware",
+			r:    &mockedServer{},
+			conf: RpcServerConf{
+				Middlewares: ServerMiddlewaresConf{
+					Trace:      true,
+					Recover:    true,
+					Stat:       true,
+					Prometheus: true,
+					Breaker:    true,
+				},
+			},
+			len: 5,
+		},
+		{
+			name: "internal middleware",
+			r:    &mockedServer{},
+			conf: RpcServerConf{
+				CpuThreshold: 900,
+				Timeout:      100,
+				Middlewares: ServerMiddlewaresConf{
+					Trace:      true,
+					Recover:    true,
+					Stat:       true,
+					Prometheus: true,
+					Breaker:    true,
+				},
+			},
+			len: 7,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			metrics := stat.NewMetrics("abc")
+			setupUnaryInterceptors(test.r, test.conf, metrics)
+			assert.Equal(t, test.len, len(test.r.unaryInterceptors))
+		})
+	}
+}
+
+func Test_setupStreamInterceptors(t *testing.T) {
+	tests := []struct {
+		name string
+		r    *mockedServer
+		conf RpcServerConf
+		len  int
+	}{
+		{
+			name: "empty",
+			r:    &mockedServer{},
+			len:  0,
+		},
+		{
+			name: "custom",
+			r: &mockedServer{
+				streamInterceptors: []grpc.StreamServerInterceptor{
+					func(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+						return handler(srv, ss)
+					},
+				},
+			},
+			len: 1,
+		},
+		{
+			name: "middleware",
+			r:    &mockedServer{},
+			conf: RpcServerConf{
+				Middlewares: ServerMiddlewaresConf{
+					Trace:      true,
+					Recover:    true,
+					Stat:       true,
+					Prometheus: true,
+					Breaker:    true,
+				},
+			},
+			len: 3,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			setupStreamInterceptors(test.r, test.conf)
+			assert.Equal(t, test.len, len(test.r.streamInterceptors))
+		})
+	}
+}
+
+func Test_setupAuthInterceptors(t *testing.T) {
+	t.Run("no need set auth", func(t *testing.T) {
+		s := &mockedServer{}
+		err := setupAuthInterceptors(s, RpcServerConf{
+			Auth:  false,
+			Redis: redis.RedisKeyConf{},
+		})
+		assert.NoError(t, err)
+	})
+
+	t.Run("redis error", func(t *testing.T) {
+		s := &mockedServer{}
+		err := setupAuthInterceptors(s, RpcServerConf{
+			Auth:  true,
+			Redis: redis.RedisKeyConf{},
+		})
+		assert.Error(t, err)
+	})
+
+	t.Run("works", func(t *testing.T) {
+		rds := miniredis.RunT(t)
+		s := &mockedServer{}
+		err := setupAuthInterceptors(s, RpcServerConf{
+			Auth: true,
+			Redis: redis.RedisKeyConf{
+				RedisConf: redis.RedisConf{
+					Host: rds.Addr(),
+					Type: redis.NodeType,
+				},
+				Key: "foo",
+			},
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(s.unaryInterceptors))
+		assert.Equal(t, 1, len(s.streamInterceptors))
+	})
+}