kubelatte-ce

1
package grpc
2

3
import (
4
	"context"
5
	"fmt"
6
	"github.com/stretchr/testify/mock"
7
	"gitverse.ru/synapse/kubelatte/pkg/observability/logger"
8
	"gitverse.ru/synapse/kubelatte/pkg/observability/logger/lib"
9
	semodles "gitverse.ru/synapse/kubelatte/pkg/sideeffect"
10
	"gitverse.ru/synapse/kubelatte/pkg/sideeffect/grpc/mocks"
11
	"gitverse.ru/synapse/kubelatte/pkg/sideeffect/grpc/proto"
12
	"gitverse.ru/synapse/kubelatte/pkg/sideeffect/sideeffect"
13
	"go.uber.org/zap"
14
	"google.golang.org/grpc"
15
	"google.golang.org/grpc/credentials/insecure"
16
	"testing"
17
)
18

19
func TestExecutorClient_GetClientError(t *testing.T) {
20
	port := 8687
21
	serverAddr := fmt.Sprintf(":%d", port)
22

23
	lib.ZapLogger = zap.NewNop()
24

25
	shutdown := StartExecuteServer(port, sideeffect.NewExecutor(nil))
26
	defer shutdown()
27

28
	var opts []grpc.DialOption
29
	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
30

31
	conn, err := grpc.Dial(serverAddr, opts...)
32
	defer func(conn *grpc.ClientConn) {
33
		err := conn.Close()
34
		if err != nil {
35
			return
36
		}
37
	}(conn)
38
	if err != nil {
39
		t.Errorf("[ProviderClient] fail to dial: %s", err.Error())
40
	}
41

42
	executorCleint := &ProviderClient{conn: conn}
43

44
	cli, done := executorCleint.GetClient()
45

46
	if done {
47
		t.Errorf("getClient() 'done' should not be 'true'")
48
	}
49

50
	if cli == nil {
51
		t.Errorf("getClient() 'client' should be not be nil")
52
	}
53
}
54

55
func TestExecutorClient_StartSideEffect(t *testing.T) {
56
	port := 8687
57
	serverAddr := fmt.Sprintf(":%d", port)
58

59
	lib.ZapLogger = zap.NewNop()
60

61
	shutdown := StartExecuteServer(port, sideeffect.NewExecutor(nil))
62
	defer shutdown()
63

64
	var opts []grpc.DialOption
65
	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
66

67
	conn, err := grpc.Dial(serverAddr, opts...)
68
	defer func(conn *grpc.ClientConn) {
69
		_ = conn.Close()
70
	}(conn)
71
	if err != nil {
72
		t.Errorf("[ProviderClient] fail to dial: %s", err.Error())
73
	}
74

75
	client := mocks.NewExecutorClient(t)
76
	client.On("DoSideEffect", mock.Anything, mock.Anything).Return(&proto.EmptyMes{}, nil).Maybe()
77

78
	type args struct {
79
		ctx  context.Context
80
		info *proto.SideEffectInfo
81
	}
82
	tests := []struct {
83
		name    string
84
		args    args
85
		want    *proto.EmptyMes
86
		conn    *grpc.ClientConn
87
		client  proto.ExecutorClient
88
		wantErr bool
89
	}{
90
		{
91
			name: "happy doSideEffect",
92
			args: args{
93
				ctx:  context.Background(),
94
				info: &proto.SideEffectInfo{},
95
			},
96
			wantErr: false,
97
			conn:    conn,
98
			client:  client,
99
			want:    &proto.EmptyMes{},
100
		},
101
	}
102

103
	for _, tt := range tests {
104
		t.Run(tt.name, func(t *testing.T) {
105
			w := ProviderClient{
106
				client: tt.client,
107
				conn:   tt.conn,
108
			}
109

110
			_, err = w.DoSideEffect(tt.args.ctx, tt.args.info)
111
			if (err != nil) != tt.wantErr {
112
				t.Errorf("doSideEffect() error = %v, wantErr %v", err, tt.wantErr)
113
				return
114
			}
115
		})
116
	}
117
}
118

119
func TestProviderClient_ApplySideEffect(t *testing.T) {
120
	port := 8687
121
	serverAddr := fmt.Sprintf(":%d", port)
122

123
	lib.ZapLogger = zap.NewNop()
124

125
	shutdown := StartExecuteServer(port, sideeffect.NewExecutor(nil))
126
	defer shutdown()
127

128
	var opts []grpc.DialOption
129
	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
130

131
	conn, err := grpc.Dial(serverAddr, opts...)
132
	defer func(conn *grpc.ClientConn) {
133
		err := conn.Close()
134
		if err != nil {
135
			return
136
		}
137
	}(conn)
138
	if err != nil {
139
		t.Errorf("[ProviderClient] fail to dial: %s", err.Error())
140
	}
141

142
	cli := mocks.NewExecutorClient(t)
143
	cli.On("DoSideEffect", mock.Anything, mock.Anything).Return(nil, nil).Maybe()
144
	provider := ProviderClient{client: cli, conn: conn}
145

146
	ctx := context.WithValue(context.Background(), logger.LoggerKey, "sth")
147
	_ = provider.ApplySideEffect(ctx, &semodles.SE{
148
		Configs: semodles.Configs{
149
			Kind:       "",
150
			ApiVersion: "",
151
			ParentTag:  0,
152
			TriggerRef: semodles.TriggerRef{
153
				SideEffectConfig: "",
154
				Name:             "",
155
				Namespace:        "",
156
			},
157
			Metadata: semodles.Metadata{
158
				Namespace: "",
159
				Name:      "",
160
			},
161
			TemplateRefs: nil,
162
		},
163
		SeMode: 0,
164
	})
165
}
166