msrc

1
package msrc
2

3
import (
4
	"context"
5
	"sync"
6
	"testing"
7
	"time"
8

9
	"github.com/pkg/errors"
10
	"github.com/sirupsen/logrus"
11
	"gitlab.systems-fd.com/packages/golang/helpers/h"
12
)
13

14
func Test_multiServiceServer_Run(t *testing.T) {
15
	type fields struct {
16
		services         map[string]ServiceInterface
17
		servicesComplete map[string]bool
18
		serviceStopFunc  *h.SyncValueStruct[context.CancelFunc]
19
		servicesIsWorkMx *sync.Mutex
20
		logger           *logrus.Entry
21
	}
22
	tests := []struct {
23
		name        string
24
		fields      fields
25
		wantErr     bool
26
		isRunCalled bool
27
	}{
28
		{
29
			name: "Тестирование отсутствия ошибки, если сервис ее не возвращает",
30
			fields: fields{
31
				services: map[string]ServiceInterface{
32
					"test-1": &serviceMock{
33
						RunIsCalled:      false,
34
						ShutdownIsCalled: false,
35
						RunResult:        nil,
36
						RunStat:          false,
37
					},
38
					"test-2": &serviceMock{
39
						RunIsCalled:      false,
40
						ShutdownIsCalled: false,
41
						RunResult:        nil,
42
						RunStat:          false,
43
					},
44
				},
45
				servicesComplete: map[string]bool{},
46
				serviceStopFunc:  h.SyncValue[context.CancelFunc](func() {}),
47
				servicesIsWorkMx: &sync.Mutex{},
48
				logger:           logrus.WithField("prefix", `test`),
49
			},
50
			wantErr:     false,
51
			isRunCalled: true,
52
		},
53
		{
54
			name: "Тестирование наличия ошибки, если сервис ее возвращает",
55
			fields: fields{
56
				services: map[string]ServiceInterface{
57
					"test-1": &serviceMock{
58
						RunIsCalled:      false,
59
						ShutdownIsCalled: false,
60
						RunResult:        errors.New("Test error"),
61
						RunStat:          false,
62
					},
63
					"test-2": &serviceMock{
64
						RunIsCalled:      false,
65
						ShutdownIsCalled: false,
66
						RunResult:        nil,
67
						RunStat:          false,
68
					},
69
				},
70
				servicesComplete: map[string]bool{},
71
				serviceStopFunc:  h.SyncValue[context.CancelFunc](func() {}),
72
				servicesIsWorkMx: &sync.Mutex{},
73
				logger:           logrus.WithField("prefix", `test`),
74
			},
75
			wantErr:     true,
76
			isRunCalled: true,
77
		},
78
	}
79
	for _, tt := range tests {
80
		t.Run(tt.name, func(t *testing.T) {
81
			m := &multiServiceServer{
82
				services:             tt.fields.services,
83
				servicesComplete:     tt.fields.servicesComplete,
84
				serviceStopFunc:      tt.fields.serviceStopFunc,
85
				servicesIsWorkMx:     tt.fields.servicesIsWorkMx,
86
				isServicesRun:        h.SyncValue[bool](false),
87
				isShutdownInProgress: h.SyncValue[bool](false),
88
				logger:               tt.fields.logger,
89
			}
90
			if err := m.Run(); (err != nil) != tt.wantErr {
91
				t.Errorf("Run() error = %v, wantErr %v", err, tt.wantErr)
92
			}
93

94
			for _, s := range tt.fields.services {
95
				if service, ok := s.(*serviceMock); ok {
96
					if service.RunIsCalled != tt.isRunCalled {
97
						t.Errorf("Run() isRunCalled = %v, want %v", service.RunIsCalled, tt.isRunCalled)
98
					}
99
				}
100
			}
101
		})
102
	}
103
}
104

105
func Test_multiServiceServer_IsServicesRun(t *testing.T) {
106
	type fields struct {
107
		services         map[string]ServiceInterface
108
		servicesComplete map[string]bool
109
		serviceStopFunc  *h.SyncValueStruct[context.CancelFunc]
110
		servicesIsWorkMx *sync.Mutex
111
		logger           *logrus.Entry
112
	}
113
	tests := []struct {
114
		name   string
115
		fields fields
116
	}{
117
		{
118
			name: "Тестирование правильности возвращения результата проверки статуса запуска",
119
			fields: fields{
120
				services: map[string]ServiceInterface{
121
					"test-1": &serviceMock{
122
						RunIsCalled:      false,
123
						ShutdownIsCalled: false,
124
						RunResult:        nil,
125
						RunStat:          false,
126
					},
127
					"test-2": &serviceMock{
128
						RunIsCalled:      false,
129
						ShutdownIsCalled: false,
130
						RunResult:        nil,
131
						RunStat:          false,
132
					},
133
					"test-3": &serviceMock{
134
						RunIsCalled:      false,
135
						ShutdownIsCalled: false,
136
						RunResult:        nil,
137
						RunStat:          false,
138
					},
139
				},
140
				servicesComplete: map[string]bool{},
141
				serviceStopFunc:  h.SyncValue[context.CancelFunc](func() {}),
142
				servicesIsWorkMx: &sync.Mutex{},
143
				logger:           logrus.WithField("prefix", `test`),
144
			},
145
		},
146
	}
147
	for _, tt := range tests {
148
		t.Run(tt.name, func(t *testing.T) {
149
			m := &multiServiceServer{
150
				services:             tt.fields.services,
151
				servicesComplete:     tt.fields.servicesComplete,
152
				serviceStopFunc:      tt.fields.serviceStopFunc,
153
				servicesIsWorkMx:     tt.fields.servicesIsWorkMx,
154
				isServicesRun:        h.SyncValue[bool](false),
155
				isShutdownInProgress: h.SyncValue[bool](false),
156
				logger:               tt.fields.logger,
157
			}
158

159
			testServices := func(flagStatus bool) {
160
				if flagStatus != m.IsServicesRun() {
161
					t.Errorf("IsServicesRun() flag = %v, want %v", m.IsServicesRun(), flagStatus)
162
				}
163
			}
164

165
			testServices(false)
166

167
			_ = m.Run()
168
			go func() {
169
				testServices(true)
170
			}()
171

172
			time.Sleep(300 * time.Millisecond)
173

174
			testServices(true)
175
		})
176
	}
177
}
178

179
func Test_multiServiceServer_IsServicesAlive(t *testing.T) {
180
	type fields struct {
181
		services         map[string]ServiceInterface
182
		servicesComplete map[string]bool
183
		serviceStopFunc  *h.SyncValueStruct[context.CancelFunc]
184
		servicesIsWorkMx *sync.Mutex
185
		logger           *logrus.Entry
186
	}
187
	tests := []struct {
188
		name   string
189
		fields fields
190
	}{
191
		{
192
			name: "Тестирование правильности возвращения результата проверки статуса рабочести",
193
			fields: fields{
194
				services: map[string]ServiceInterface{
195
					"test-1": &serviceMock{
196
						RunIsCalled:      false,
197
						ShutdownIsCalled: false,
198
						RunResult:        nil,
199
						RunStat:          false,
200
					},
201
					"test-2": &serviceMock{
202
						RunIsCalled:      false,
203
						ShutdownIsCalled: false,
204
						RunResult:        nil,
205
						RunStat:          false,
206
					},
207
					"test-3": &serviceMock{
208
						RunIsCalled:      false,
209
						ShutdownIsCalled: false,
210
						RunResult:        nil,
211
						RunStat:          false,
212
					},
213
				},
214
				servicesComplete: map[string]bool{},
215
				serviceStopFunc:  h.SyncValue[context.CancelFunc](func() {}),
216
				servicesIsWorkMx: &sync.Mutex{},
217
				logger:           logrus.WithField("prefix", `test`),
218
			},
219
		},
220
	}
221
	for _, tt := range tests {
222
		t.Run(tt.name, func(t *testing.T) {
223
			m := &multiServiceServer{
224
				services:             tt.fields.services,
225
				servicesComplete:     tt.fields.servicesComplete,
226
				serviceStopFunc:      tt.fields.serviceStopFunc,
227
				servicesIsWorkMx:     tt.fields.servicesIsWorkMx,
228
				isServicesRun:        h.SyncValue[bool](false),
229
				isShutdownInProgress: h.SyncValue[bool](false),
230
				logger:               tt.fields.logger,
231
			}
232

233
			testServices := func(flagStatus bool) {
234
				if flagStatus != m.IsServicesAlive() {
235
					t.Errorf("IsServicesAlive() flag = %v, want %v", m.IsServicesAlive(), flagStatus)
236
				}
237
			}
238

239
			testServices(false)
240

241
			go func() {
242
				time.Sleep(100 * time.Millisecond)
243

244
				testServices(true)
245
			}()
246
			_ = m.Run()
247

248
			time.Sleep(300 * time.Millisecond)
249

250
			testServices(false)
251
		})
252
	}
253
}
254

255
func Test_multiServiceServer_Stop(t *testing.T) {
256
	type fields struct {
257
		services         map[string]ServiceInterface
258
		servicesComplete map[string]bool
259
		serviceStopFunc  *h.SyncValueStruct[context.CancelFunc]
260
		servicesIsWorkMx *sync.Mutex
261
		logger           *logrus.Entry
262
		wait             int
263
	}
264
	tests := []struct {
265
		name             string
266
		fields           fields
267
		isShutdownCalled bool
268
	}{
269
		{
270
			name: "Тестирование правильности работы остановки сервиса",
271
			fields: fields{
272
				services: map[string]ServiceInterface{
273
					"test-1": &serviceMock{
274
						RunIsCalled:      false,
275
						ShutdownIsCalled: false,
276
						RunResult:        nil,
277
						RunStat:          false,
278
					},
279
					"test-2": &serviceMock{
280
						RunIsCalled:      false,
281
						ShutdownIsCalled: false,
282
						RunResult:        nil,
283
						RunStat:          false,
284
					},
285
					"test-3": &serviceMock{
286
						RunIsCalled:      false,
287
						ShutdownIsCalled: false,
288
						RunResult:        nil,
289
						RunStat:          false,
290
					},
291
				},
292
				servicesComplete: map[string]bool{},
293
				serviceStopFunc:  h.SyncValue[context.CancelFunc](func() {}),
294
				servicesIsWorkMx: &sync.Mutex{},
295
				logger:           logrus.WithField("prefix", `test`),
296
				wait:             800,
297
			},
298
			isShutdownCalled: false,
299
		},
300
		{
301
			name: "Тестирование правильности работы остановки сервиса",
302
			fields: fields{
303
				services: map[string]ServiceInterface{
304
					"test-1": &serviceMock{
305
						RunIsCalled:      false,
306
						ShutdownIsCalled: false,
307
						RunResult:        nil,
308
						RunStat:          false,
309
					},
310
					"test-2": &serviceMock{
311
						RunIsCalled:      false,
312
						ShutdownIsCalled: false,
313
						RunResult:        nil,
314
						RunStat:          false,
315
					},
316
					"test-3": &serviceMock{
317
						RunIsCalled:      false,
318
						ShutdownIsCalled: false,
319
						RunResult:        nil,
320
						RunStat:          false,
321
					},
322
				},
323
				servicesComplete: map[string]bool{},
324
				serviceStopFunc:  h.SyncValue[context.CancelFunc](func() {}),
325
				servicesIsWorkMx: &sync.Mutex{},
326
				logger:           logrus.WithField("prefix", `test`),
327
				wait:             100,
328
			},
329
			isShutdownCalled: true,
330
		},
331
	}
332
	for _, tt := range tests {
333
		t.Run(tt.name, func(t *testing.T) {
334
			m := &multiServiceServer{
335
				services:             tt.fields.services,
336
				servicesComplete:     tt.fields.servicesComplete,
337
				serviceStopFunc:      tt.fields.serviceStopFunc,
338
				servicesIsWorkMx:     tt.fields.servicesIsWorkMx,
339
				isServicesRun:        h.SyncValue[bool](false),
340
				isShutdownInProgress: h.SyncValue[bool](false),
341
				logger:               tt.fields.logger,
342
			}
343

344
			go func() {
345
				time.Sleep(time.Duration(tt.fields.wait) * time.Millisecond)
346

347
				m.Stop()
348
			}()
349

350
			_ = m.Run()
351

352
			for _, s := range tt.fields.services {
353
				if service, ok := s.(*serviceMock); ok {
354
					if service.ShutdownIsCalled != tt.isShutdownCalled {
355
						t.Errorf("Stop() isShutdownCalled = %v, want %v", service.ShutdownIsCalled, tt.isShutdownCalled)
356
					}
357
				}
358
			}
359
		})
360
	}
361
}
362