Dragonfly2

1
/*
2
 *     Copyright 2020 The Dragonfly Authors
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package resource
18

19
import (
20
	"testing"
21
	"time"
22

23
	"github.com/stretchr/testify/assert"
24
	"go.uber.org/atomic"
25

26
	commonv2 "d7y.io/api/v2/pkg/apis/common/v2"
27

28
	"d7y.io/dragonfly/v2/pkg/idgen"
29
	"d7y.io/dragonfly/v2/pkg/types"
30
	"d7y.io/dragonfly/v2/scheduler/config"
31
)
32

33
var (
34
	mockRawHost = Host{
35
		ID:              mockHostID,
36
		Type:            types.HostTypeNormal,
37
		Hostname:        "foo",
38
		IP:              "127.0.0.1",
39
		Port:            8003,
40
		DownloadPort:    8001,
41
		OS:              "darwin",
42
		Platform:        "darwin",
43
		PlatformFamily:  "Standalone Workstation",
44
		PlatformVersion: "11.1",
45
		KernelVersion:   "20.2.0",
46
		CPU:             mockCPU,
47
		Memory:          mockMemory,
48
		Network:         mockNetwork,
49
		Disk:            mockDisk,
50
		Build:           mockBuild,
51
		CreatedAt:       atomic.NewTime(time.Now()),
52
		UpdatedAt:       atomic.NewTime(time.Now()),
53
	}
54

55
	mockRawSeedHost = Host{
56
		ID:              mockSeedHostID,
57
		Type:            types.HostTypeSuperSeed,
58
		Hostname:        "bar",
59
		IP:              "127.0.0.1",
60
		Port:            8003,
61
		DownloadPort:    8001,
62
		OS:              "darwin",
63
		Platform:        "darwin",
64
		PlatformFamily:  "Standalone Workstation",
65
		PlatformVersion: "11.1",
66
		KernelVersion:   "20.2.0",
67
		CPU:             mockCPU,
68
		Memory:          mockMemory,
69
		Network:         mockNetwork,
70
		Disk:            mockDisk,
71
		Build:           mockBuild,
72
		CreatedAt:       atomic.NewTime(time.Now()),
73
		UpdatedAt:       atomic.NewTime(time.Now()),
74
	}
75

76
	mockCPU = CPU{
77
		LogicalCount:   4,
78
		PhysicalCount:  2,
79
		Percent:        1,
80
		ProcessPercent: 0.5,
81
		Times: CPUTimes{
82
			User:      240662.2,
83
			System:    317950.1,
84
			Idle:      3393691.3,
85
			Nice:      0,
86
			Iowait:    0,
87
			Irq:       0,
88
			Softirq:   0,
89
			Steal:     0,
90
			Guest:     0,
91
			GuestNice: 0,
92
		},
93
	}
94

95
	mockMemory = Memory{
96
		Total:              17179869184,
97
		Available:          5962813440,
98
		Used:               11217055744,
99
		UsedPercent:        65.291858,
100
		ProcessUsedPercent: 41.525125,
101
		Free:               2749598908,
102
	}
103

104
	mockNetwork = Network{
105
		TCPConnectionCount:       10,
106
		UploadTCPConnectionCount: 1,
107
		Location:                 mockHostLocation,
108
		IDC:                      mockHostIDC,
109
	}
110

111
	mockDisk = Disk{
112
		Total:             499963174912,
113
		Free:              37226479616,
114
		Used:              423809622016,
115
		UsedPercent:       91.92547406065952,
116
		InodesTotal:       4882452880,
117
		InodesUsed:        7835772,
118
		InodesFree:        4874617108,
119
		InodesUsedPercent: 0.1604884305611568,
120
	}
121

122
	mockBuild = Build{
123
		GitVersion: "v1.0.0",
124
		GitCommit:  "221176b117c6d59366d68f2b34d38be50c935883",
125
		GoVersion:  "1.18",
126
		Platform:   "darwin",
127
	}
128

129
	mockHostID       = idgen.HostIDV2("127.0.0.1", "foo")
130
	mockSeedHostID   = idgen.HostIDV2("127.0.0.1", "bar")
131
	mockHostLocation = "baz"
132
	mockHostIDC      = "bas"
133
)
134

135
func TestHost_NewHost(t *testing.T) {
136
	tests := []struct {
137
		name    string
138
		rawHost Host
139
		options []HostOption
140
		expect  func(t *testing.T, host *Host)
141
	}{
142
		{
143
			name:    "new host",
144
			rawHost: mockRawHost,
145
			expect: func(t *testing.T, host *Host) {
146
				assert := assert.New(t)
147
				assert.Equal(host.ID, mockRawHost.ID)
148
				assert.Equal(host.Type, types.HostTypeNormal)
149
				assert.Equal(host.Hostname, mockRawHost.Hostname)
150
				assert.Equal(host.IP, mockRawHost.IP)
151
				assert.Equal(host.Port, mockRawHost.Port)
152
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
153
				assert.Equal(host.ObjectStoragePort, int32(0))
154
				assert.Equal(host.SchedulerClusterID, uint64(0))
155
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
156
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
157
				assert.Equal(host.UploadCount.Load(), int64(0))
158
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
159
				assert.NotNil(host.Peers)
160
				assert.Equal(host.PeerCount.Load(), int32(0))
161
				assert.NotEmpty(host.CreatedAt.Load())
162
				assert.NotEmpty(host.UpdatedAt.Load())
163
				assert.NotNil(host.Log)
164
			},
165
		},
166
		{
167
			name:    "new seed host",
168
			rawHost: mockRawSeedHost,
169
			expect: func(t *testing.T, host *Host) {
170
				assert := assert.New(t)
171
				assert.Equal(host.ID, mockRawSeedHost.ID)
172
				assert.Equal(host.Type, mockRawSeedHost.Type)
173
				assert.Equal(host.Hostname, mockRawSeedHost.Hostname)
174
				assert.Equal(host.IP, mockRawSeedHost.IP)
175
				assert.Equal(host.Port, mockRawSeedHost.Port)
176
				assert.Equal(host.DownloadPort, mockRawSeedHost.DownloadPort)
177
				assert.Equal(host.ObjectStoragePort, int32(0))
178
				assert.Equal(host.SchedulerClusterID, uint64(0))
179
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultSeedPeerConcurrentUploadLimit))
180
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
181
				assert.Equal(host.UploadCount.Load(), int64(0))
182
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
183
				assert.NotNil(host.Peers)
184
				assert.Equal(host.PeerCount.Load(), int32(0))
185
				assert.NotEmpty(host.CreatedAt.Load())
186
				assert.NotEmpty(host.UpdatedAt.Load())
187
				assert.NotNil(host.Log)
188
			},
189
		},
190
		{
191
			name:    "new host and set scheduler cluster id",
192
			rawHost: mockRawHost,
193
			options: []HostOption{WithSchedulerClusterID(1)},
194
			expect: func(t *testing.T, host *Host) {
195
				assert := assert.New(t)
196
				assert.Equal(host.ID, mockRawHost.ID)
197
				assert.Equal(host.Type, types.HostTypeNormal)
198
				assert.Equal(host.Hostname, mockRawHost.Hostname)
199
				assert.Equal(host.IP, mockRawHost.IP)
200
				assert.Equal(host.Port, mockRawHost.Port)
201
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
202
				assert.Equal(host.SchedulerClusterID, uint64(1))
203
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
204
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
205
				assert.Equal(host.UploadCount.Load(), int64(0))
206
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
207
				assert.NotNil(host.Peers)
208
				assert.Equal(host.PeerCount.Load(), int32(0))
209
				assert.NotEmpty(host.CreatedAt.Load())
210
				assert.NotEmpty(host.UpdatedAt.Load())
211
				assert.NotNil(host.Log)
212
			},
213
		},
214
		{
215
			name:    "new host and set object storage port",
216
			rawHost: mockRawHost,
217
			options: []HostOption{WithObjectStoragePort(1)},
218
			expect: func(t *testing.T, host *Host) {
219
				assert := assert.New(t)
220
				assert.Equal(host.ID, mockRawHost.ID)
221
				assert.Equal(host.Type, types.HostTypeNormal)
222
				assert.Equal(host.Hostname, mockRawHost.Hostname)
223
				assert.Equal(host.IP, mockRawHost.IP)
224
				assert.Equal(host.Port, mockRawHost.Port)
225
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
226
				assert.Equal(host.ObjectStoragePort, int32(1))
227
				assert.Equal(host.SchedulerClusterID, uint64(0))
228
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
229
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
230
				assert.Equal(host.UploadCount.Load(), int64(0))
231
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
232
				assert.NotNil(host.Peers)
233
				assert.Equal(host.PeerCount.Load(), int32(0))
234
				assert.NotEmpty(host.CreatedAt.Load())
235
				assert.NotEmpty(host.UpdatedAt.Load())
236
				assert.NotNil(host.Log)
237
			},
238
		},
239
		{
240
			name:    "new host and set upload loadlimit",
241
			rawHost: mockRawHost,
242
			options: []HostOption{WithConcurrentUploadLimit(200)},
243
			expect: func(t *testing.T, host *Host) {
244
				assert := assert.New(t)
245
				assert.Equal(host.ID, mockRawHost.ID)
246
				assert.Equal(host.Type, types.HostTypeNormal)
247
				assert.Equal(host.Hostname, mockRawHost.Hostname)
248
				assert.Equal(host.IP, mockRawHost.IP)
249
				assert.Equal(host.Port, mockRawHost.Port)
250
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
251
				assert.Equal(host.ObjectStoragePort, int32(0))
252
				assert.Equal(host.SchedulerClusterID, uint64(0))
253
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(200))
254
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
255
				assert.Equal(host.UploadCount.Load(), int64(0))
256
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
257
				assert.NotNil(host.Peers)
258
				assert.Equal(host.PeerCount.Load(), int32(0))
259
				assert.NotEmpty(host.CreatedAt.Load())
260
				assert.NotEmpty(host.UpdatedAt.Load())
261
				assert.NotNil(host.Log)
262
			},
263
		},
264
		{
265
			name:    "new host and set os",
266
			rawHost: mockRawHost,
267
			options: []HostOption{WithOS("linux")},
268
			expect: func(t *testing.T, host *Host) {
269
				assert := assert.New(t)
270
				assert.Equal(host.ID, mockRawHost.ID)
271
				assert.Equal(host.Type, types.HostTypeNormal)
272
				assert.Equal(host.Hostname, mockRawHost.Hostname)
273
				assert.Equal(host.IP, mockRawHost.IP)
274
				assert.Equal(host.Port, mockRawHost.Port)
275
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
276
				assert.Equal(host.ObjectStoragePort, int32(0))
277
				assert.Equal(host.OS, "linux")
278
				assert.Equal(host.SchedulerClusterID, uint64(0))
279
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
280
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
281
				assert.Equal(host.UploadCount.Load(), int64(0))
282
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
283
				assert.NotNil(host.Peers)
284
				assert.Equal(host.PeerCount.Load(), int32(0))
285
				assert.NotEmpty(host.CreatedAt.Load())
286
				assert.NotEmpty(host.UpdatedAt.Load())
287
				assert.NotNil(host.Log)
288
			},
289
		},
290
		{
291
			name:    "new host and set platform",
292
			rawHost: mockRawHost,
293
			options: []HostOption{WithPlatform("ubuntu")},
294
			expect: func(t *testing.T, host *Host) {
295
				assert := assert.New(t)
296
				assert.Equal(host.ID, mockRawHost.ID)
297
				assert.Equal(host.Type, types.HostTypeNormal)
298
				assert.Equal(host.Hostname, mockRawHost.Hostname)
299
				assert.Equal(host.IP, mockRawHost.IP)
300
				assert.Equal(host.Port, mockRawHost.Port)
301
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
302
				assert.Equal(host.ObjectStoragePort, int32(0))
303
				assert.Equal(host.Platform, "ubuntu")
304
				assert.Equal(host.SchedulerClusterID, uint64(0))
305
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
306
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
307
				assert.Equal(host.UploadCount.Load(), int64(0))
308
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
309
				assert.NotNil(host.Peers)
310
				assert.Equal(host.PeerCount.Load(), int32(0))
311
				assert.NotEmpty(host.CreatedAt.Load())
312
				assert.NotEmpty(host.UpdatedAt.Load())
313
				assert.NotNil(host.Log)
314
			},
315
		},
316
		{
317
			name:    "new host and set platform family",
318
			rawHost: mockRawHost,
319
			options: []HostOption{WithPlatformFamily("debian")},
320
			expect: func(t *testing.T, host *Host) {
321
				assert := assert.New(t)
322
				assert.Equal(host.ID, mockRawHost.ID)
323
				assert.Equal(host.Type, types.HostTypeNormal)
324
				assert.Equal(host.Hostname, mockRawHost.Hostname)
325
				assert.Equal(host.IP, mockRawHost.IP)
326
				assert.Equal(host.Port, mockRawHost.Port)
327
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
328
				assert.Equal(host.ObjectStoragePort, int32(0))
329
				assert.Equal(host.PlatformFamily, "debian")
330
				assert.Equal(host.SchedulerClusterID, uint64(0))
331
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
332
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
333
				assert.Equal(host.UploadCount.Load(), int64(0))
334
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
335
				assert.NotNil(host.Peers)
336
				assert.Equal(host.PeerCount.Load(), int32(0))
337
				assert.NotEmpty(host.CreatedAt.Load())
338
				assert.NotEmpty(host.UpdatedAt.Load())
339
				assert.NotNil(host.Log)
340
			},
341
		},
342
		{
343
			name:    "new host and set platform version",
344
			rawHost: mockRawHost,
345
			options: []HostOption{WithPlatformVersion("22.04")},
346
			expect: func(t *testing.T, host *Host) {
347
				assert := assert.New(t)
348
				assert.Equal(host.ID, mockRawHost.ID)
349
				assert.Equal(host.Type, types.HostTypeNormal)
350
				assert.Equal(host.Hostname, mockRawHost.Hostname)
351
				assert.Equal(host.IP, mockRawHost.IP)
352
				assert.Equal(host.Port, mockRawHost.Port)
353
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
354
				assert.Equal(host.ObjectStoragePort, int32(0))
355
				assert.Equal(host.PlatformVersion, "22.04")
356
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
357
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
358
				assert.Equal(host.UploadCount.Load(), int64(0))
359
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
360
				assert.NotNil(host.Peers)
361
				assert.Equal(host.PeerCount.Load(), int32(0))
362
				assert.NotEmpty(host.CreatedAt.Load())
363
				assert.NotEmpty(host.UpdatedAt.Load())
364
				assert.NotNil(host.Log)
365
			},
366
		},
367
		{
368
			name:    "new host and set kernel version",
369
			rawHost: mockRawHost,
370
			options: []HostOption{WithKernelVersion("5.15.0-27-generic")},
371
			expect: func(t *testing.T, host *Host) {
372
				assert := assert.New(t)
373
				assert.Equal(host.ID, mockRawHost.ID)
374
				assert.Equal(host.Type, types.HostTypeNormal)
375
				assert.Equal(host.Hostname, mockRawHost.Hostname)
376
				assert.Equal(host.IP, mockRawHost.IP)
377
				assert.Equal(host.Port, mockRawHost.Port)
378
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
379
				assert.Equal(host.ObjectStoragePort, int32(0))
380
				assert.Equal(host.KernelVersion, "5.15.0-27-generic")
381
				assert.Equal(host.SchedulerClusterID, uint64(0))
382
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
383
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
384
				assert.Equal(host.UploadCount.Load(), int64(0))
385
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
386
				assert.NotNil(host.Peers)
387
				assert.Equal(host.PeerCount.Load(), int32(0))
388
				assert.NotEmpty(host.CreatedAt.Load())
389
				assert.NotEmpty(host.UpdatedAt.Load())
390
				assert.NotNil(host.Log)
391
			},
392
		},
393
		{
394
			name:    "new host and set cpu",
395
			rawHost: mockRawHost,
396
			options: []HostOption{WithCPU(mockCPU)},
397
			expect: func(t *testing.T, host *Host) {
398
				assert := assert.New(t)
399
				assert.Equal(host.ID, mockRawHost.ID)
400
				assert.Equal(host.Type, types.HostTypeNormal)
401
				assert.Equal(host.Hostname, mockRawHost.Hostname)
402
				assert.Equal(host.IP, mockRawHost.IP)
403
				assert.Equal(host.Port, mockRawHost.Port)
404
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
405
				assert.Equal(host.ObjectStoragePort, int32(0))
406
				assert.EqualValues(host.CPU, mockCPU)
407
				assert.Equal(host.SchedulerClusterID, uint64(0))
408
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
409
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
410
				assert.Equal(host.UploadCount.Load(), int64(0))
411
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
412
				assert.NotNil(host.Peers)
413
				assert.Equal(host.PeerCount.Load(), int32(0))
414
				assert.NotEmpty(host.CreatedAt.Load())
415
				assert.NotEmpty(host.UpdatedAt.Load())
416
				assert.NotNil(host.Log)
417
			},
418
		},
419
		{
420
			name:    "new host and set memory",
421
			rawHost: mockRawHost,
422
			options: []HostOption{WithMemory(mockMemory)},
423
			expect: func(t *testing.T, host *Host) {
424
				assert := assert.New(t)
425
				assert.Equal(host.ID, mockRawHost.ID)
426
				assert.Equal(host.Type, types.HostTypeNormal)
427
				assert.Equal(host.Hostname, mockRawHost.Hostname)
428
				assert.Equal(host.IP, mockRawHost.IP)
429
				assert.Equal(host.Port, mockRawHost.Port)
430
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
431
				assert.Equal(host.ObjectStoragePort, int32(0))
432
				assert.EqualValues(host.Memory, mockMemory)
433
				assert.Equal(host.SchedulerClusterID, uint64(0))
434
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
435
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
436
				assert.Equal(host.UploadCount.Load(), int64(0))
437
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
438
				assert.NotNil(host.Peers)
439
				assert.Equal(host.PeerCount.Load(), int32(0))
440
				assert.NotEmpty(host.CreatedAt.Load())
441
				assert.NotEmpty(host.UpdatedAt.Load())
442
				assert.NotNil(host.Log)
443
			},
444
		},
445
		{
446
			name:    "new host and set network",
447
			rawHost: mockRawHost,
448
			options: []HostOption{WithNetwork(mockNetwork)},
449
			expect: func(t *testing.T, host *Host) {
450
				assert := assert.New(t)
451
				assert.Equal(host.ID, mockRawHost.ID)
452
				assert.Equal(host.Type, types.HostTypeNormal)
453
				assert.Equal(host.Hostname, mockRawHost.Hostname)
454
				assert.Equal(host.IP, mockRawHost.IP)
455
				assert.Equal(host.Port, mockRawHost.Port)
456
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
457
				assert.Equal(host.ObjectStoragePort, int32(0))
458
				assert.EqualValues(host.Network, mockNetwork)
459
				assert.Equal(host.SchedulerClusterID, uint64(0))
460
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
461
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
462
				assert.Equal(host.UploadCount.Load(), int64(0))
463
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
464
				assert.NotNil(host.Peers)
465
				assert.Equal(host.PeerCount.Load(), int32(0))
466
				assert.NotEmpty(host.CreatedAt.Load())
467
				assert.NotEmpty(host.UpdatedAt.Load())
468
				assert.NotNil(host.Log)
469
			},
470
		},
471
		{
472
			name:    "new host and set disk",
473
			rawHost: mockRawHost,
474
			options: []HostOption{WithDisk(mockDisk)},
475
			expect: func(t *testing.T, host *Host) {
476
				assert := assert.New(t)
477
				assert.Equal(host.ID, mockRawHost.ID)
478
				assert.Equal(host.Type, types.HostTypeNormal)
479
				assert.Equal(host.Hostname, mockRawHost.Hostname)
480
				assert.Equal(host.IP, mockRawHost.IP)
481
				assert.Equal(host.Port, mockRawHost.Port)
482
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
483
				assert.Equal(host.ObjectStoragePort, int32(0))
484
				assert.EqualValues(host.Disk, mockDisk)
485
				assert.Equal(host.SchedulerClusterID, uint64(0))
486
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
487
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
488
				assert.Equal(host.UploadCount.Load(), int64(0))
489
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
490
				assert.NotNil(host.Peers)
491
				assert.Equal(host.PeerCount.Load(), int32(0))
492
				assert.NotEmpty(host.CreatedAt.Load())
493
				assert.NotEmpty(host.UpdatedAt.Load())
494
				assert.NotNil(host.Log)
495
			},
496
		},
497
		{
498
			name:    "new host and set build",
499
			rawHost: mockRawHost,
500
			options: []HostOption{WithBuild(mockBuild)},
501
			expect: func(t *testing.T, host *Host) {
502
				assert := assert.New(t)
503
				assert.Equal(host.ID, mockRawHost.ID)
504
				assert.Equal(host.Type, types.HostTypeNormal)
505
				assert.Equal(host.Hostname, mockRawHost.Hostname)
506
				assert.Equal(host.IP, mockRawHost.IP)
507
				assert.Equal(host.Port, mockRawHost.Port)
508
				assert.Equal(host.DownloadPort, mockRawHost.DownloadPort)
509
				assert.Equal(host.ObjectStoragePort, int32(0))
510
				assert.EqualValues(host.Build, mockBuild)
511
				assert.Equal(host.SchedulerClusterID, uint64(0))
512
				assert.Equal(host.ConcurrentUploadLimit.Load(), int32(config.DefaultPeerConcurrentUploadLimit))
513
				assert.Equal(host.ConcurrentUploadCount.Load(), int32(0))
514
				assert.Equal(host.UploadCount.Load(), int64(0))
515
				assert.Equal(host.UploadFailedCount.Load(), int64(0))
516
				assert.NotNil(host.Peers)
517
				assert.Equal(host.PeerCount.Load(), int32(0))
518
				assert.NotEmpty(host.CreatedAt.Load())
519
				assert.NotEmpty(host.UpdatedAt.Load())
520
				assert.NotNil(host.Log)
521
			},
522
		},
523
	}
524

525
	for _, tc := range tests {
526
		t.Run(tc.name, func(t *testing.T) {
527
			tc.expect(t, NewHost(
528
				tc.rawHost.ID, tc.rawHost.IP, tc.rawHost.Hostname,
529
				tc.rawHost.Port, tc.rawHost.DownloadPort, tc.rawHost.Type,
530
				tc.options...))
531
		})
532
	}
533
}
534

535
func TestHost_LoadPeer(t *testing.T) {
536
	tests := []struct {
537
		name    string
538
		rawHost Host
539
		peerID  string
540
		expect  func(t *testing.T, peer *Peer, loaded bool)
541
	}{
542
		{
543
			name:    "load peer",
544
			rawHost: mockRawHost,
545
			peerID:  mockPeerID,
546
			expect: func(t *testing.T, peer *Peer, loaded bool) {
547
				assert := assert.New(t)
548
				assert.Equal(loaded, true)
549
				assert.Equal(peer.ID, mockPeerID)
550
			},
551
		},
552
		{
553
			name:    "peer does not exist",
554
			rawHost: mockRawHost,
555
			peerID:  idgen.PeerIDV1("0.0.0.0"),
556
			expect: func(t *testing.T, peer *Peer, loaded bool) {
557
				assert := assert.New(t)
558
				assert.Equal(loaded, false)
559
			},
560
		},
561
		{
562
			name:    "load key is empty",
563
			rawHost: mockRawHost,
564
			peerID:  "",
565
			expect: func(t *testing.T, peer *Peer, loaded bool) {
566
				assert := assert.New(t)
567
				assert.Equal(loaded, false)
568
			},
569
		},
570
	}
571

572
	for _, tc := range tests {
573
		t.Run(tc.name, func(t *testing.T) {
574
			host := NewHost(
575
				tc.rawHost.ID, tc.rawHost.IP, tc.rawHost.Hostname,
576
				tc.rawHost.Port, tc.rawHost.DownloadPort, tc.rawHost.Type)
577
			mockTask := NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilteredQueryParams, mockTaskHeader, mockTaskBackToSourceLimit, WithDigest(mockTaskDigest))
578
			mockPeer := NewPeer(mockPeerID, mockResourceConfig, mockTask, host)
579

580
			host.StorePeer(mockPeer)
581
			peer, loaded := host.LoadPeer(tc.peerID)
582
			tc.expect(t, peer, loaded)
583
		})
584
	}
585
}
586

587
func TestHost_StorePeer(t *testing.T) {
588
	tests := []struct {
589
		name    string
590
		rawHost Host
591
		peerID  string
592
		options []HostOption
593
		expect  func(t *testing.T, peer *Peer, loaded bool)
594
	}{
595
		{
596
			name:    "store peer",
597
			rawHost: mockRawHost,
598
			peerID:  mockPeerID,
599
			expect: func(t *testing.T, peer *Peer, loaded bool) {
600
				assert := assert.New(t)
601
				assert.Equal(loaded, true)
602
				assert.Equal(peer.ID, mockPeerID)
603
			},
604
		},
605
		{
606
			name:    "store key is empty",
607
			rawHost: mockRawHost,
608
			peerID:  "",
609
			expect: func(t *testing.T, peer *Peer, loaded bool) {
610
				assert := assert.New(t)
611
				assert.Equal(loaded, true)
612
				assert.Equal(peer.ID, "")
613
			},
614
		},
615
	}
616

617
	for _, tc := range tests {
618
		t.Run(tc.name, func(t *testing.T) {
619
			host := NewHost(
620
				tc.rawHost.ID, tc.rawHost.IP, tc.rawHost.Hostname,
621
				tc.rawHost.Port, tc.rawHost.DownloadPort, tc.rawHost.Type)
622
			mockTask := NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilteredQueryParams, mockTaskHeader, mockTaskBackToSourceLimit, WithDigest(mockTaskDigest))
623
			mockPeer := NewPeer(tc.peerID, mockResourceConfig, mockTask, host)
624

625
			host.StorePeer(mockPeer)
626
			peer, loaded := host.LoadPeer(tc.peerID)
627
			tc.expect(t, peer, loaded)
628
		})
629
	}
630
}
631

632
func TestHost_DeletePeer(t *testing.T) {
633
	tests := []struct {
634
		name    string
635
		rawHost Host
636
		peerID  string
637
		options []HostOption
638
		expect  func(t *testing.T, host *Host)
639
	}{
640
		{
641
			name:    "delete peer",
642
			rawHost: mockRawHost,
643
			peerID:  mockPeerID,
644
			expect: func(t *testing.T, host *Host) {
645
				assert := assert.New(t)
646
				_, loaded := host.LoadPeer(mockPeerID)
647
				assert.Equal(loaded, false)
648
			},
649
		},
650
		{
651
			name:    "delete key is empty",
652
			rawHost: mockRawHost,
653
			peerID:  "",
654
			expect: func(t *testing.T, host *Host) {
655
				assert := assert.New(t)
656
				peer, loaded := host.LoadPeer(mockPeerID)
657
				assert.Equal(loaded, true)
658
				assert.Equal(peer.ID, mockPeerID)
659
			},
660
		},
661
	}
662

663
	for _, tc := range tests {
664
		t.Run(tc.name, func(t *testing.T) {
665
			host := NewHost(
666
				tc.rawHost.ID, tc.rawHost.IP, tc.rawHost.Hostname,
667
				tc.rawHost.Port, tc.rawHost.DownloadPort, tc.rawHost.Type)
668
			mockTask := NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilteredQueryParams, mockTaskHeader, mockTaskBackToSourceLimit, WithDigest(mockTaskDigest))
669
			mockPeer := NewPeer(mockPeerID, mockResourceConfig, mockTask, host)
670

671
			host.StorePeer(mockPeer)
672
			host.DeletePeer(tc.peerID)
673
			tc.expect(t, host)
674
		})
675
	}
676
}
677

678
func TestHost_LeavePeers(t *testing.T) {
679
	tests := []struct {
680
		name    string
681
		rawHost Host
682
		options []HostOption
683
		expect  func(t *testing.T, host *Host, mockPeer *Peer)
684
	}{
685
		{
686
			name:    "leave peers",
687
			rawHost: mockRawHost,
688
			expect: func(t *testing.T, host *Host, mockPeer *Peer) {
689
				assert := assert.New(t)
690
				host.StorePeer(mockPeer)
691
				assert.Equal(host.PeerCount.Load(), int32(1))
692
				host.LeavePeers()
693
				host.Peers.Range(func(_, value any) bool {
694
					peer := value.(*Peer)
695
					assert.True(peer.FSM.Is(PeerStateLeave))
696
					return true
697
				})
698
			},
699
		},
700
		{
701
			name:    "peers is empty ",
702
			rawHost: mockRawHost,
703
			expect: func(t *testing.T, host *Host, mockPeer *Peer) {
704
				assert := assert.New(t)
705
				assert.Equal(host.PeerCount.Load(), int32(0))
706
				host.LeavePeers()
707
				host.Peers.Range(func(_, value any) bool {
708
					assert.Fail("host peers is not empty")
709
					return true
710
				})
711
			},
712
		},
713
	}
714

715
	for _, tc := range tests {
716
		t.Run(tc.name, func(t *testing.T) {
717
			host := NewHost(
718
				tc.rawHost.ID, tc.rawHost.IP, tc.rawHost.Hostname,
719
				tc.rawHost.Port, tc.rawHost.DownloadPort, tc.rawHost.Type)
720
			mockTask := NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilteredQueryParams, mockTaskHeader, mockTaskBackToSourceLimit, WithDigest(mockTaskDigest))
721
			mockPeer := NewPeer(mockPeerID, mockResourceConfig, mockTask, host)
722

723
			tc.expect(t, host, mockPeer)
724
		})
725
	}
726
}
727

728
func TestHost_FreeUploadCount(t *testing.T) {
729
	tests := []struct {
730
		name    string
731
		rawHost Host
732
		options []HostOption
733
		expect  func(t *testing.T, host *Host, mockTask *Task, mockPeer *Peer)
734
	}{
735
		{
736
			name:    "get free upload load",
737
			rawHost: mockRawHost,
738
			expect: func(t *testing.T, host *Host, mockTask *Task, mockPeer *Peer) {
739
				assert := assert.New(t)
740
				mockSeedPeer := NewPeer(mockSeedPeerID, mockResourceConfig, mockTask, host)
741
				mockPeer.Task.StorePeer(mockSeedPeer)
742
				mockPeer.Task.StorePeer(mockPeer)
743
				err := mockPeer.Task.AddPeerEdge(mockSeedPeer, mockPeer)
744
				assert.NoError(err)
745
				assert.Equal(host.FreeUploadCount(), int32(config.DefaultPeerConcurrentUploadLimit-1))
746
				err = mockTask.DeletePeerInEdges(mockPeer.ID)
747
				assert.NoError(err)
748
				assert.Equal(host.FreeUploadCount(), int32(config.DefaultPeerConcurrentUploadLimit))
749
				err = mockPeer.Task.AddPeerEdge(mockSeedPeer, mockPeer)
750
				assert.NoError(err)
751
				assert.Equal(host.FreeUploadCount(), int32(config.DefaultPeerConcurrentUploadLimit-1))
752
				err = mockTask.DeletePeerOutEdges(mockSeedPeer.ID)
753
				assert.NoError(err)
754
				assert.Equal(host.FreeUploadCount(), int32(config.DefaultPeerConcurrentUploadLimit))
755
			},
756
		},
757
		{
758
			name:    "upload peer does not exist",
759
			rawHost: mockRawHost,
760
			expect: func(t *testing.T, host *Host, mockTask *Task, mockPeer *Peer) {
761
				assert := assert.New(t)
762
				assert.Equal(host.FreeUploadCount(), int32(config.DefaultPeerConcurrentUploadLimit))
763
			},
764
		},
765
	}
766

767
	for _, tc := range tests {
768
		t.Run(tc.name, func(t *testing.T) {
769
			host := NewHost(
770
				tc.rawHost.ID, tc.rawHost.IP, tc.rawHost.Hostname,
771
				tc.rawHost.Port, tc.rawHost.DownloadPort, tc.rawHost.Type)
772
			mockTask := NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilteredQueryParams, mockTaskHeader, mockTaskBackToSourceLimit, WithDigest(mockTaskDigest))
773
			mockPeer := NewPeer(mockPeerID, mockResourceConfig, mockTask, host)
774

775
			tc.expect(t, host, mockTask, mockPeer)
776
		})
777
	}
778
}
779