Dragonfly2

1
/*
2
 *     Copyright 2022 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 storage
18

19
import (
20
	"fmt"
21
	"io/fs"
22
	"os"
23
	"path/filepath"
24
	"reflect"
25
	"regexp"
26
	"testing"
27
	"time"
28

29
	"github.com/gocarina/gocsv"
30
	"github.com/stretchr/testify/assert"
31

32
	"d7y.io/dragonfly/v2/scheduler/config"
33
	"d7y.io/dragonfly/v2/scheduler/resource"
34
)
35

36
var (
37
	mockTask = Task{
38
		ID:                    "1",
39
		URL:                   "example.com",
40
		Type:                  "normal",
41
		ContentLength:         2048,
42
		TotalPieceCount:       1,
43
		BackToSourceLimit:     10,
44
		BackToSourcePeerCount: 2,
45
		State:                 "Succeeded",
46
		CreatedAt:             time.Now().UnixNano(),
47
		UpdatedAt:             time.Now().UnixNano(),
48
	}
49

50
	mockHost = Host{
51
		ID:                    "2",
52
		Type:                  "normal",
53
		Hostname:              "localhost",
54
		IP:                    "127.0.0.1",
55
		Port:                  8080,
56
		DownloadPort:          8081,
57
		OS:                    "linux",
58
		Platform:              "ubuntu",
59
		PlatformFamily:        "debian",
60
		PlatformVersion:       "1.0.0",
61
		KernelVersion:         "1.0.0",
62
		ConcurrentUploadLimit: 100,
63
		ConcurrentUploadCount: 40,
64
		UploadCount:           20,
65
		UploadFailedCount:     3,
66
		CPU: resource.CPU{
67
			LogicalCount:   24,
68
			PhysicalCount:  12,
69
			Percent:        0.8,
70
			ProcessPercent: 0.4,
71
			Times: resource.CPUTimes{
72
				User:      100,
73
				System:    101,
74
				Idle:      102,
75
				Nice:      103,
76
				Iowait:    104,
77
				Irq:       105,
78
				Softirq:   106,
79
				Steal:     107,
80
				Guest:     108,
81
				GuestNice: 109,
82
			},
83
		},
84
		Memory: resource.Memory{
85
			Total:              20,
86
			Available:          19,
87
			Used:               16,
88
			UsedPercent:        0.7,
89
			ProcessUsedPercent: 0.2,
90
			Free:               15,
91
		},
92
		Network: resource.Network{
93
			TCPConnectionCount:       400,
94
			UploadTCPConnectionCount: 200,
95
			Location:                 "china",
96
			IDC:                      "e1",
97
		},
98
		Disk: resource.Disk{
99
			Total:             100,
100
			Free:              88,
101
			Used:              56,
102
			UsedPercent:       0.9,
103
			InodesTotal:       200,
104
			InodesUsed:        180,
105
			InodesFree:        160,
106
			InodesUsedPercent: 0.6,
107
		},
108
		Build: resource.Build{
109
			GitVersion: "3.0.0",
110
			GitCommit:  "2bf4d5e",
111
			GoVersion:  "1.19",
112
			Platform:   "linux",
113
		},
114
		SchedulerClusterID: 1,
115
		CreatedAt:          time.Now().UnixNano(),
116
		UpdatedAt:          time.Now().UnixNano(),
117
	}
118

119
	mockPiece = Piece{
120
		Length:    20,
121
		Cost:      10,
122
		CreatedAt: time.Now().UnixNano(),
123
	}
124

125
	mockPieces = append(make([]Piece, 9), mockPiece)
126

127
	mockParent = Parent{
128
		ID:                 "4",
129
		Tag:                "m",
130
		Application:        "db",
131
		State:              "Succeeded",
132
		Cost:               1000,
133
		UploadPieceCount:   10,
134
		FinishedPieceCount: 10,
135
		Host:               mockHost,
136
		Pieces:             mockPieces,
137
		CreatedAt:          time.Now().UnixNano(),
138
		UpdatedAt:          time.Now().UnixNano(),
139
	}
140

141
	mockParents = append(make([]Parent, 19), mockParent)
142

143
	mockDownload = Download{
144
		ID:          "5",
145
		Tag:         "d",
146
		Application: "mq",
147
		State:       "Succeeded",
148
		Error: Error{
149
			Code:    "unknow",
150
			Message: "unknow",
151
		},
152
		Cost:               1000,
153
		FinishedPieceCount: 10,
154
		Task:               mockTask,
155
		Host:               mockHost,
156
		Parents:            mockParents,
157
		CreatedAt:          time.Now().UnixNano(),
158
		UpdatedAt:          time.Now().UnixNano(),
159
	}
160

161
	mockSrcHost = SrcHost{
162
		ID:       "3",
163
		Type:     "super",
164
		Hostname: "foo",
165
		IP:       "127.0.0.1",
166
		Port:     8080,
167
		Network: resource.Network{
168
			TCPConnectionCount:       400,
169
			UploadTCPConnectionCount: 200,
170
			Location:                 "china",
171
			IDC:                      "e1",
172
		},
173
	}
174

175
	mockDestHost = DestHost{
176
		ID:       "2",
177
		Type:     "normal",
178
		Hostname: "localhost",
179
		IP:       "127.0.0.1",
180
		Port:     8080,
181
		Network: resource.Network{
182
			TCPConnectionCount:       400,
183
			UploadTCPConnectionCount: 200,
184
			Location:                 "china",
185
			IDC:                      "e1",
186
		},
187
		Probes: Probes{
188
			AverageRTT: 10,
189
			CreatedAt:  time.Now().UnixNano(),
190
			UpdatedAt:  time.Now().UnixNano(),
191
		},
192
	}
193

194
	mockDestHosts = []DestHost{mockDestHost, mockDestHost, mockDestHost, mockDestHost, mockDestHost}
195

196
	mockNetworkTopology = NetworkTopology{
197
		ID:        "6",
198
		Host:      mockSrcHost,
199
		DestHosts: mockDestHosts,
200
		CreatedAt: time.Now().UnixNano(),
201
	}
202
)
203

204
func TestStorage_New(t *testing.T) {
205
	tests := []struct {
206
		name    string
207
		baseDir string
208
		expect  func(t *testing.T, s Storage, err error)
209
	}{
210
		{
211
			name:    "new storage",
212
			baseDir: os.TempDir(),
213
			expect: func(t *testing.T, s Storage, err error) {
214
				assert := assert.New(t)
215
				assert.NoError(err)
216
				assert.Equal(reflect.TypeOf(s).Elem().Name(), "storage")
217
				assert.Equal(s.(*storage).maxSize, int64(config.DefaultStorageMaxSize*megabyte))
218
				assert.Equal(s.(*storage).maxBackups, config.DefaultStorageMaxBackups)
219
				assert.Equal(s.(*storage).bufferSize, config.DefaultStorageBufferSize)
220

221
				assert.Equal(cap(s.(*storage).downloadBuffer), config.DefaultStorageBufferSize)
222
				assert.Equal(len(s.(*storage).downloadBuffer), 0)
223
				assert.Equal(s.(*storage).downloadCount, int64(0))
224

225
				assert.Equal(cap(s.(*storage).networkTopologyBuffer), config.DefaultStorageBufferSize)
226
				assert.Equal(len(s.(*storage).networkTopologyBuffer), 0)
227
				assert.Equal(s.(*storage).networkTopologyCount, int64(0))
228

229
				if err := s.ClearDownload(); err != nil {
230
					t.Fatal(err)
231
				}
232

233
				if err := s.ClearNetworkTopology(); err != nil {
234
					t.Fatal(err)
235
				}
236
			},
237
		},
238
		{
239
			name:    "new storage failed",
240
			baseDir: "/foo",
241
			expect: func(t *testing.T, s Storage, err error) {
242
				assert := assert.New(t)
243
				assert.Error(err)
244
			},
245
		},
246
	}
247

248
	for _, tc := range tests {
249
		t.Run(tc.name, func(t *testing.T) {
250
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
251
			tc.expect(t, s, err)
252
		})
253
	}
254
}
255

256
func TestStorage_CreateDownload(t *testing.T) {
257
	tests := []struct {
258
		name       string
259
		baseDir    string
260
		bufferSize int
261
		mock       func(s Storage)
262
		expect     func(t *testing.T, s Storage, baseDir string)
263
	}{
264
		{
265
			name:       "create download",
266
			baseDir:    os.TempDir(),
267
			bufferSize: 1,
268
			mock:       func(s Storage) {},
269
			expect: func(t *testing.T, s Storage, baseDir string) {
270
				assert := assert.New(t)
271
				assert.NoError(s.CreateDownload(Download{}))
272
				assert.Equal(s.(*storage).downloadCount, int64(0))
273
			},
274
		},
275
		{
276
			name:       "create download without buffer",
277
			baseDir:    os.TempDir(),
278
			bufferSize: 0,
279
			mock: func(s Storage) {
280
			},
281
			expect: func(t *testing.T, s Storage, baseDir string) {
282
				assert := assert.New(t)
283
				assert.NoError(s.CreateDownload(Download{}))
284
				assert.Equal(s.(*storage).downloadCount, int64(1))
285

286
				downloads, err := s.ListDownload()
287
				assert.NoError(err)
288
				assert.Equal(len(downloads), 1)
289
			},
290
		},
291
		{
292
			name:       "write download to file",
293
			baseDir:    os.TempDir(),
294
			bufferSize: 1,
295
			mock: func(s Storage) {
296
			},
297
			expect: func(t *testing.T, s Storage, baseDir string) {
298
				assert := assert.New(t)
299
				assert.NoError(s.CreateDownload(Download{}))
300
				assert.NoError(s.CreateDownload(Download{}))
301
				assert.Equal(s.(*storage).downloadCount, int64(1))
302
			},
303
		},
304
		{
305
			name:       "open file failed",
306
			baseDir:    os.TempDir(),
307
			bufferSize: 0,
308
			mock: func(s Storage) {
309
				s.(*storage).baseDir = "foo"
310
			},
311
			expect: func(t *testing.T, s Storage, baseDir string) {
312
				assert := assert.New(t)
313
				assert.Error(s.CreateDownload(Download{}))
314
				s.(*storage).baseDir = baseDir
315
			},
316
		},
317
	}
318

319
	for _, tc := range tests {
320
		t.Run(tc.name, func(t *testing.T) {
321
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, tc.bufferSize)
322
			if err != nil {
323
				t.Fatal(err)
324
			}
325

326
			tc.mock(s)
327
			tc.expect(t, s, tc.baseDir)
328
			if err := s.ClearDownload(); err != nil {
329
				t.Fatal(err)
330
			}
331
		})
332
	}
333
}
334

335
func TestStorage_CreateNetworkTopology(t *testing.T) {
336
	tests := []struct {
337
		name       string
338
		baseDir    string
339
		bufferSize int
340
		mock       func(s Storage)
341
		expect     func(t *testing.T, s Storage, baseDir string)
342
	}{
343
		{
344
			name:       "create network topology",
345
			baseDir:    os.TempDir(),
346
			bufferSize: 1,
347
			mock:       func(s Storage) {},
348
			expect: func(t *testing.T, s Storage, baseDir string) {
349
				assert := assert.New(t)
350
				assert.NoError(s.CreateNetworkTopology(NetworkTopology{}))
351
				assert.Equal(s.(*storage).networkTopologyCount, int64(0))
352
			},
353
		},
354
		{
355
			name:       "create network topology without buffer",
356
			baseDir:    os.TempDir(),
357
			bufferSize: 0,
358
			mock: func(s Storage) {
359
			},
360
			expect: func(t *testing.T, s Storage, baseDir string) {
361
				assert := assert.New(t)
362
				assert.NoError(s.CreateNetworkTopology(NetworkTopology{}))
363
				assert.Equal(s.(*storage).networkTopologyCount, int64(1))
364

365
				networkTopologies, err := s.ListNetworkTopology()
366
				assert.NoError(err)
367
				assert.Equal(len(networkTopologies), 1)
368
			},
369
		},
370
		{
371
			name:       "write network topology to file",
372
			baseDir:    os.TempDir(),
373
			bufferSize: 1,
374
			mock: func(s Storage) {
375
			},
376
			expect: func(t *testing.T, s Storage, baseDir string) {
377
				assert := assert.New(t)
378
				assert.NoError(s.CreateNetworkTopology(NetworkTopology{}))
379
				assert.NoError(s.CreateNetworkTopology(NetworkTopology{}))
380
				assert.Equal(s.(*storage).networkTopologyCount, int64(1))
381
			},
382
		},
383
		{
384
			name:       "open file failed",
385
			baseDir:    os.TempDir(),
386
			bufferSize: 0,
387
			mock: func(s Storage) {
388
				s.(*storage).baseDir = "baw"
389
			},
390
			expect: func(t *testing.T, s Storage, baseDir string) {
391
				assert := assert.New(t)
392
				assert.Error(s.CreateNetworkTopology(NetworkTopology{}))
393
				s.(*storage).baseDir = baseDir
394
			},
395
		},
396
	}
397

398
	for _, tc := range tests {
399
		t.Run(tc.name, func(t *testing.T) {
400
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, tc.bufferSize)
401
			if err != nil {
402
				t.Fatal(err)
403
			}
404

405
			tc.mock(s)
406
			tc.expect(t, s, tc.baseDir)
407
			if err := s.ClearNetworkTopology(); err != nil {
408
				t.Fatal(err)
409
			}
410
		})
411
	}
412
}
413

414
func TestStorage_ListDownload(t *testing.T) {
415
	tests := []struct {
416
		name       string
417
		baseDir    string
418
		bufferSize int
419
		download   Download
420
		mock       func(t *testing.T, s Storage, baseDir string, download Download)
421
		expect     func(t *testing.T, s Storage, baseDir string, download Download)
422
	}{
423
		{
424
			name:       "empty csv file given",
425
			baseDir:    os.TempDir(),
426
			bufferSize: config.DefaultStorageBufferSize,
427
			mock:       func(t *testing.T, s Storage, baseDir string, download Download) {},
428
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
429
				assert := assert.New(t)
430
				_, err := s.ListDownload()
431
				assert.Error(err)
432
			},
433
		},
434
		{
435
			name:       "get file infos failed",
436
			baseDir:    os.TempDir(),
437
			bufferSize: config.DefaultStorageBufferSize,
438
			mock: func(t *testing.T, s Storage, baseDir string, download Download) {
439
				s.(*storage).baseDir = "bae"
440
			},
441
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
442
				assert := assert.New(t)
443
				_, err := s.ListDownload()
444
				assert.Error(err)
445
				s.(*storage).baseDir = baseDir
446
			},
447
		},
448
		{
449
			name:       "open file failed",
450
			baseDir:    os.TempDir(),
451
			bufferSize: config.DefaultStorageBufferSize,
452
			mock: func(t *testing.T, s Storage, baseDir string, download Download) {
453
				file, err := os.OpenFile(filepath.Join(baseDir, "download_test.csv"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0300)
454
				if err != nil {
455
					t.Fatal(err)
456
				}
457
				file.Close()
458
			},
459
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
460
				assert := assert.New(t)
461
				_, err := s.ListDownload()
462
				assert.Error(err)
463
			},
464
		},
465
		{
466
			name:       "list downloads of a file",
467
			baseDir:    os.TempDir(),
468
			bufferSize: 1,
469
			download:   mockDownload,
470
			mock: func(t *testing.T, s Storage, baseDir string, download Download) {
471
				if err := s.CreateDownload(download); err != nil {
472
					t.Fatal(err)
473
				}
474
			},
475
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
476
				assert := assert.New(t)
477
				_, err := s.ListDownload()
478
				assert.Error(err)
479

480
				if err := s.CreateDownload(download); err != nil {
481
					t.Fatal(err)
482
				}
483
				downloads, err := s.ListDownload()
484
				assert.NoError(err)
485
				assert.Equal(len(downloads), 1)
486
				assert.EqualValues(downloads[0].ID, download.ID)
487
				assert.EqualValues(downloads[0].Tag, download.Tag)
488
				assert.EqualValues(downloads[0].Application, download.Application)
489
				assert.EqualValues(downloads[0].State, download.State)
490
				assert.EqualValues(downloads[0].Error, download.Error)
491
				assert.EqualValues(downloads[0].Cost, download.Cost)
492
				assert.EqualValues(downloads[0].Task, download.Task)
493
				assert.EqualValues(downloads[0].Host, download.Host)
494
				assert.EqualValues(downloads[0].CreatedAt, download.CreatedAt)
495
				assert.EqualValues(downloads[0].UpdatedAt, download.UpdatedAt)
496
			},
497
		},
498
		{
499
			name:       "list downloads of multi files",
500
			baseDir:    os.TempDir(),
501
			bufferSize: 1,
502
			download:   Download{},
503
			mock: func(t *testing.T, s Storage, baseDir string, download Download) {
504
				if err := s.CreateDownload(Download{ID: "2"}); err != nil {
505
					t.Fatal(err)
506
				}
507

508
				if err := s.CreateDownload(Download{ID: "1"}); err != nil {
509
					t.Fatal(err)
510
				}
511

512
				if err := s.CreateDownload(Download{ID: "3"}); err != nil {
513
					t.Fatal(err)
514
				}
515
			},
516
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
517
				assert := assert.New(t)
518
				downloads, err := s.ListDownload()
519
				assert.NoError(err)
520
				assert.Equal(len(downloads), 2)
521
				assert.Equal(downloads[0].ID, "2")
522
				assert.Equal(downloads[1].ID, "1")
523
			},
524
		},
525
	}
526

527
	for _, tc := range tests {
528
		t.Run(tc.name, func(t *testing.T) {
529
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, tc.bufferSize)
530
			if err != nil {
531
				t.Fatal(err)
532
			}
533

534
			tc.mock(t, s, tc.baseDir, tc.download)
535
			tc.expect(t, s, tc.baseDir, tc.download)
536
			if err := s.ClearDownload(); err != nil {
537
				t.Fatal(err)
538
			}
539
		})
540
	}
541
}
542

543
func TestStorage_ListNetworkTopology(t *testing.T) {
544
	tests := []struct {
545
		name            string
546
		baseDir         string
547
		bufferSize      int
548
		networkTopology NetworkTopology
549
		mock            func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology)
550
		expect          func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology)
551
	}{
552
		{
553
			name:       "empty csv file given",
554
			baseDir:    os.TempDir(),
555
			bufferSize: config.DefaultStorageBufferSize,
556
			mock:       func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {},
557
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
558
				assert := assert.New(t)
559
				_, err := s.ListNetworkTopology()
560
				assert.Error(err)
561
			},
562
		},
563
		{
564
			name:       "get file infos failed",
565
			baseDir:    os.TempDir(),
566
			bufferSize: config.DefaultStorageBufferSize,
567
			mock: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
568
				s.(*storage).baseDir = "bae"
569
			},
570
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
571
				assert := assert.New(t)
572
				_, err := s.ListNetworkTopology()
573
				assert.Error(err)
574
				s.(*storage).baseDir = baseDir
575
			},
576
		},
577
		{
578
			name:       "open file failed",
579
			baseDir:    os.TempDir(),
580
			bufferSize: config.DefaultStorageBufferSize,
581
			mock: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
582
				file, err := os.OpenFile(filepath.Join(baseDir, "networktopology_test.csv"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0300)
583
				if err != nil {
584
					t.Fatal(err)
585
				}
586
				file.Close()
587
			},
588
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
589
				assert := assert.New(t)
590
				_, err := s.ListNetworkTopology()
591
				assert.Error(err)
592
			},
593
		},
594
		{
595
			name:            "list network topologies of a file",
596
			baseDir:         os.TempDir(),
597
			bufferSize:      1,
598
			networkTopology: mockNetworkTopology,
599
			mock: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
600
				if err := s.CreateNetworkTopology(networkTopology); err != nil {
601
					t.Fatal(err)
602
				}
603
			},
604
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
605
				assert := assert.New(t)
606
				_, err := s.ListNetworkTopology()
607
				assert.Error(err)
608

609
				if err := s.CreateNetworkTopology(networkTopology); err != nil {
610
					t.Fatal(err)
611
				}
612
				networkTopologies, err := s.ListNetworkTopology()
613
				assert.NoError(err)
614
				assert.Equal(len(networkTopologies), 1)
615
				assert.EqualValues(networkTopologies[0], networkTopology)
616
			},
617
		},
618
		{
619
			name:            "list network topologies of multi files",
620
			baseDir:         os.TempDir(),
621
			bufferSize:      1,
622
			networkTopology: NetworkTopology{},
623
			mock: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
624
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "2"}); err != nil {
625
					t.Fatal(err)
626
				}
627

628
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "1"}); err != nil {
629
					t.Fatal(err)
630
				}
631

632
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "3"}); err != nil {
633
					t.Fatal(err)
634
				}
635
			},
636
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
637
				assert := assert.New(t)
638
				networkTopologies, err := s.ListNetworkTopology()
639
				assert.NoError(err)
640
				assert.Equal(len(networkTopologies), 2)
641
				assert.Equal(networkTopologies[0].ID, "2")
642
				assert.Equal(networkTopologies[1].ID, "1")
643
			},
644
		},
645
	}
646

647
	for _, tc := range tests {
648
		t.Run(tc.name, func(t *testing.T) {
649
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, tc.bufferSize)
650
			if err != nil {
651
				t.Fatal(err)
652
			}
653

654
			tc.mock(t, s, tc.baseDir, tc.networkTopology)
655
			tc.expect(t, s, tc.baseDir, tc.networkTopology)
656
			if err := s.ClearNetworkTopology(); err != nil {
657
				t.Fatal(err)
658
			}
659
		})
660
	}
661
}
662

663
func TestStorage_DownloadCount(t *testing.T) {
664
	tests := []struct {
665
		name    string
666
		baseDir string
667
		mock    func(s Storage)
668
		expect  func(t *testing.T, s Storage)
669
	}{
670
		{
671
			name:    "get the count of downloads",
672
			baseDir: os.TempDir(),
673
			mock: func(s Storage) {
674
				s.(*storage).downloadCount = 2
675
			},
676
			expect: func(t *testing.T, s Storage) {
677
				assert := assert.New(t)
678
				assert.Equal(int64(2), s.DownloadCount())
679
			},
680
		},
681
	}
682

683
	for _, tc := range tests {
684
		t.Run(tc.name, func(t *testing.T) {
685
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
686
			if err != nil {
687
				t.Fatal(err)
688
			}
689

690
			tc.mock(s)
691
			tc.expect(t, s)
692
		})
693
	}
694
}
695

696
func TestStorage_NetworkTopologyCount(t *testing.T) {
697
	tests := []struct {
698
		name    string
699
		baseDir string
700
		mock    func(s Storage)
701
		expect  func(t *testing.T, s Storage)
702
	}{
703
		{
704
			name:    "get the count of network topologies",
705
			baseDir: os.TempDir(),
706
			mock: func(s Storage) {
707
				s.(*storage).networkTopologyCount = 1
708
			},
709
			expect: func(t *testing.T, s Storage) {
710
				assert := assert.New(t)
711
				assert.Equal(int64(1), s.NetworkTopologyCount())
712
			},
713
		},
714
	}
715
	for _, tc := range tests {
716
		t.Run(tc.name, func(t *testing.T) {
717
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
718
			if err != nil {
719
				t.Fatal(err)
720
			}
721

722
			tc.mock(s)
723
			tc.expect(t, s)
724
		})
725
	}
726
}
727

728
func TestStorage_OpenDownload(t *testing.T) {
729
	tests := []struct {
730
		name       string
731
		baseDir    string
732
		bufferSize int
733
		download   Download
734
		mock       func(t *testing.T, s Storage, baseDir string, download Download)
735
		expect     func(t *testing.T, s Storage, baseDir string, download Download)
736
	}{
737
		{
738
			name:       "open storage withempty csv file given",
739
			baseDir:    os.TempDir(),
740
			bufferSize: config.DefaultStorageBufferSize,
741
			mock:       func(t *testing.T, s Storage, baseDir string, download Download) {},
742
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
743
				assert := assert.New(t)
744
				_, err := s.OpenDownload()
745
				assert.NoError(err)
746
			},
747
		},
748
		{
749
			name:       "open file infos failed",
750
			baseDir:    os.TempDir(),
751
			bufferSize: config.DefaultStorageBufferSize,
752
			mock: func(t *testing.T, s Storage, baseDir string, download Download) {
753
				s.(*storage).baseDir = "bas"
754
			},
755
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
756
				assert := assert.New(t)
757
				_, err := s.OpenDownload()
758
				assert.Error(err)
759
				s.(*storage).baseDir = baseDir
760
			},
761
		},
762
		{
763
			name:       "open storage with downloads of a file",
764
			baseDir:    os.TempDir(),
765
			bufferSize: 1,
766
			download:   mockDownload,
767
			mock: func(t *testing.T, s Storage, baseDir string, download Download) {
768
				if err := s.CreateDownload(download); err != nil {
769
					t.Fatal(err)
770
				}
771
			},
772
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
773
				assert := assert.New(t)
774
				_, err := s.OpenDownload()
775
				assert.NoError(err)
776

777
				if err := s.CreateDownload(download); err != nil {
778
					t.Fatal(err)
779
				}
780

781
				readCloser, err := s.OpenDownload()
782
				assert.NoError(err)
783

784
				var downloads []Download
785
				err = gocsv.UnmarshalWithoutHeaders(readCloser, &downloads)
786
				assert.NoError(err)
787
				assert.Equal(len(downloads), 1)
788
				assert.EqualValues(downloads[0].ID, download.ID)
789
				assert.EqualValues(downloads[0].Tag, download.Tag)
790
				assert.EqualValues(downloads[0].Application, download.Application)
791
				assert.EqualValues(downloads[0].State, download.State)
792
				assert.EqualValues(downloads[0].Error, download.Error)
793
				assert.EqualValues(downloads[0].Cost, download.Cost)
794
				assert.EqualValues(downloads[0].Task, download.Task)
795
				assert.EqualValues(downloads[0].Host, download.Host)
796
				assert.EqualValues(downloads[0].CreatedAt, download.CreatedAt)
797
				assert.EqualValues(downloads[0].UpdatedAt, download.UpdatedAt)
798
			},
799
		},
800
		{
801
			name:       "open storage with downloads of multi files",
802
			baseDir:    os.TempDir(),
803
			bufferSize: 1,
804
			download:   Download{},
805
			mock: func(t *testing.T, s Storage, baseDir string, download Download) {
806
				if err := s.CreateDownload(Download{ID: "2"}); err != nil {
807
					t.Fatal(err)
808
				}
809

810
				if err := s.CreateDownload(Download{ID: "1"}); err != nil {
811
					t.Fatal(err)
812
				}
813

814
				if err := s.CreateDownload(Download{ID: "3"}); err != nil {
815
					t.Fatal(err)
816
				}
817
			},
818
			expect: func(t *testing.T, s Storage, baseDir string, download Download) {
819
				assert := assert.New(t)
820
				readCloser, err := s.OpenDownload()
821
				assert.NoError(err)
822

823
				var downloads []Download
824
				err = gocsv.UnmarshalWithoutHeaders(readCloser, &downloads)
825
				assert.NoError(err)
826
				assert.Equal(len(downloads), 2)
827
				assert.Equal(downloads[0].ID, "2")
828
				assert.Equal(downloads[1].ID, "1")
829
			},
830
		},
831
	}
832

833
	for _, tc := range tests {
834
		t.Run(tc.name, func(t *testing.T) {
835
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, tc.bufferSize)
836
			if err != nil {
837
				t.Fatal(err)
838
			}
839

840
			tc.mock(t, s, tc.baseDir, tc.download)
841
			tc.expect(t, s, tc.baseDir, tc.download)
842
			if err := s.ClearDownload(); err != nil {
843
				t.Fatal(err)
844
			}
845
		})
846
	}
847
}
848

849
func TestStorage_OpenNetworkTopology(t *testing.T) {
850
	tests := []struct {
851
		name            string
852
		baseDir         string
853
		bufferSize      int
854
		networkTopology NetworkTopology
855
		mock            func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology)
856
		expect          func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology)
857
	}{
858
		{
859
			name:       "open storage with empty csv file given",
860
			baseDir:    os.TempDir(),
861
			bufferSize: config.DefaultStorageBufferSize,
862
			mock:       func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {},
863
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
864
				assert := assert.New(t)
865
				_, err := s.OpenNetworkTopology()
866
				assert.NoError(err)
867
			},
868
		},
869
		{
870
			name:       "open file infos failed",
871
			baseDir:    os.TempDir(),
872
			bufferSize: config.DefaultStorageBufferSize,
873
			mock: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
874
				s.(*storage).baseDir = "bas"
875
			},
876
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
877
				assert := assert.New(t)
878
				_, err := s.OpenNetworkTopology()
879
				assert.Error(err)
880
				s.(*storage).baseDir = baseDir
881
			},
882
		},
883
		{
884
			name:            "open storage with network topologies of a file",
885
			baseDir:         os.TempDir(),
886
			bufferSize:      1,
887
			networkTopology: mockNetworkTopology,
888
			mock: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
889
				if err := s.CreateNetworkTopology(networkTopology); err != nil {
890
					t.Fatal(err)
891
				}
892
			},
893
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
894
				assert := assert.New(t)
895
				_, err := s.OpenNetworkTopology()
896
				assert.NoError(err)
897

898
				if err := s.CreateNetworkTopology(networkTopology); err != nil {
899
					t.Fatal(err)
900
				}
901

902
				readCloser, err := s.OpenNetworkTopology()
903
				assert.NoError(err)
904

905
				var networkTopologies []NetworkTopology
906
				err = gocsv.UnmarshalWithoutHeaders(readCloser, &networkTopologies)
907
				assert.NoError(err)
908
				assert.Equal(len(networkTopologies), 1)
909
				assert.EqualValues(networkTopologies[0], networkTopology)
910
			},
911
		},
912
		{
913
			name:            "open storage with network topologies of multi files",
914
			baseDir:         os.TempDir(),
915
			bufferSize:      1,
916
			networkTopology: NetworkTopology{},
917
			mock: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
918
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "2"}); err != nil {
919
					t.Fatal(err)
920
				}
921

922
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "1"}); err != nil {
923
					t.Fatal(err)
924
				}
925

926
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "3"}); err != nil {
927
					t.Fatal(err)
928
				}
929
			},
930
			expect: func(t *testing.T, s Storage, baseDir string, networkTopology NetworkTopology) {
931
				assert := assert.New(t)
932
				readCloser, err := s.OpenNetworkTopology()
933
				assert.NoError(err)
934

935
				var networkTopologies []NetworkTopology
936
				err = gocsv.UnmarshalWithoutHeaders(readCloser, &networkTopologies)
937
				assert.NoError(err)
938
				assert.Equal(len(networkTopologies), 2)
939
				assert.Equal(networkTopologies[0].ID, "2")
940
				assert.Equal(networkTopologies[1].ID, "1")
941
			},
942
		},
943
	}
944

945
	for _, tc := range tests {
946
		t.Run(tc.name, func(t *testing.T) {
947
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, tc.bufferSize)
948
			if err != nil {
949
				t.Fatal(err)
950
			}
951

952
			tc.mock(t, s, tc.baseDir, tc.networkTopology)
953
			tc.expect(t, s, tc.baseDir, tc.networkTopology)
954
			if err := s.ClearNetworkTopology(); err != nil {
955
				t.Fatal(err)
956
			}
957
		})
958
	}
959
}
960

961
func TestStorage_ClearDownload(t *testing.T) {
962
	tests := []struct {
963
		name    string
964
		baseDir string
965
		mock    func(s Storage)
966
		expect  func(t *testing.T, s Storage, baseDir string)
967
	}{
968
		{
969
			name:    "clear file",
970
			baseDir: os.TempDir(),
971
			mock:    func(s Storage) {},
972
			expect: func(t *testing.T, s Storage, baseDir string) {
973
				assert := assert.New(t)
974
				assert.NoError(s.ClearDownload())
975
				fileInfos, err := os.ReadDir(filepath.Join(baseDir))
976
				assert.NoError(err)
977

978
				var backups []os.DirEntry
979
				regexp := regexp.MustCompile(DownloadFilePrefix)
980
				for _, fileInfo := range fileInfos {
981
					if !fileInfo.IsDir() && regexp.MatchString(fileInfo.Name()) {
982
						backups = append(backups, fileInfo)
983
					}
984
				}
985
				assert.Equal(len(backups), 0)
986
			},
987
		},
988
		{
989
			name:    "open file failed",
990
			baseDir: os.TempDir(),
991
			mock: func(s Storage) {
992
				s.(*storage).baseDir = "baz"
993
			},
994
			expect: func(t *testing.T, s Storage, baseDir string) {
995
				assert := assert.New(t)
996
				assert.Error(s.ClearDownload())
997

998
				s.(*storage).baseDir = baseDir
999
				assert.NoError(s.ClearDownload())
1000
			},
1001
		},
1002
	}
1003

1004
	for _, tc := range tests {
1005
		t.Run(tc.name, func(t *testing.T) {
1006
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1007
			if err != nil {
1008
				t.Fatal(err)
1009
			}
1010

1011
			tc.mock(s)
1012
			tc.expect(t, s, tc.baseDir)
1013
		})
1014
	}
1015
}
1016

1017
func TestStorage_ClearNetworkTopology(t *testing.T) {
1018
	tests := []struct {
1019
		name    string
1020
		baseDir string
1021
		mock    func(s Storage)
1022
		expect  func(t *testing.T, s Storage, baseDir string)
1023
	}{
1024
		{
1025
			name:    "clear file",
1026
			baseDir: os.TempDir(),
1027
			mock:    func(s Storage) {},
1028
			expect: func(t *testing.T, s Storage, baseDir string) {
1029
				assert := assert.New(t)
1030
				assert.NoError(s.ClearNetworkTopology())
1031
				fileInfos, err := os.ReadDir(filepath.Join(baseDir))
1032
				assert.NoError(err)
1033

1034
				var backups []fs.FileInfo
1035
				regexp := regexp.MustCompile(NetworkTopologyFilePrefix)
1036
				for _, fileInfo := range fileInfos {
1037
					if !fileInfo.IsDir() && regexp.MatchString(fileInfo.Name()) {
1038
						info, _ := fileInfo.Info()
1039
						backups = append(backups, info)
1040
					}
1041
				}
1042
				assert.Equal(len(backups), 0)
1043
			},
1044
		},
1045
		{
1046
			name:    "open file failed",
1047
			baseDir: os.TempDir(),
1048
			mock: func(s Storage) {
1049
				s.(*storage).baseDir = "baz"
1050
			},
1051
			expect: func(t *testing.T, s Storage, baseDir string) {
1052
				assert := assert.New(t)
1053
				assert.Error(s.ClearNetworkTopology())
1054

1055
				s.(*storage).baseDir = baseDir
1056
				assert.NoError(s.ClearNetworkTopology())
1057
			},
1058
		},
1059
	}
1060

1061
	for _, tc := range tests {
1062
		t.Run(tc.name, func(t *testing.T) {
1063
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1064
			if err != nil {
1065
				t.Fatal(err)
1066
			}
1067

1068
			tc.mock(s)
1069
			tc.expect(t, s, tc.baseDir)
1070
		})
1071
	}
1072
}
1073

1074
func TestStorage_createDownload(t *testing.T) {
1075
	tests := []struct {
1076
		name    string
1077
		baseDir string
1078
		mock    func(s Storage)
1079
		expect  func(t *testing.T, s Storage, baseDir string)
1080
	}{
1081
		{
1082
			name:    "create download",
1083
			baseDir: os.TempDir(),
1084
			mock:    func(s Storage) {},
1085
			expect: func(t *testing.T, s Storage, baseDir string) {
1086
				assert := assert.New(t)
1087
				assert.NoError(s.(*storage).createDownload(Download{}))
1088
			},
1089
		},
1090
		{
1091
			name:    "open file failed",
1092
			baseDir: os.TempDir(),
1093
			mock: func(s Storage) {
1094
				s.(*storage).baseDir = "foo"
1095
			},
1096
			expect: func(t *testing.T, s Storage, baseDir string) {
1097
				assert := assert.New(t)
1098
				assert.Error(s.(*storage).createDownload(Download{}))
1099
				s.(*storage).baseDir = baseDir
1100
			},
1101
		},
1102
	}
1103

1104
	for _, tc := range tests {
1105
		t.Run(tc.name, func(t *testing.T) {
1106
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1107
			if err != nil {
1108
				t.Fatal(err)
1109
			}
1110

1111
			tc.mock(s)
1112
			tc.expect(t, s, tc.baseDir)
1113
			if err := s.ClearDownload(); err != nil {
1114
				t.Fatal(err)
1115
			}
1116
		})
1117
	}
1118
}
1119

1120
func TestStorage_createNetworkTopology(t *testing.T) {
1121
	tests := []struct {
1122
		name    string
1123
		baseDir string
1124
		mock    func(s Storage)
1125
		expect  func(t *testing.T, s Storage, baseDir string)
1126
	}{
1127
		{
1128
			name:    "create network topology",
1129
			baseDir: os.TempDir(),
1130
			mock:    func(s Storage) {},
1131
			expect: func(t *testing.T, s Storage, baseDir string) {
1132
				assert := assert.New(t)
1133
				assert.NoError(s.(*storage).createNetworkTopology(NetworkTopology{}))
1134
			},
1135
		},
1136
		{
1137
			name:    "open file failed",
1138
			baseDir: os.TempDir(),
1139
			mock: func(s Storage) {
1140
				s.(*storage).baseDir = "baw"
1141
			},
1142
			expect: func(t *testing.T, s Storage, baseDir string) {
1143
				assert := assert.New(t)
1144
				assert.Error(s.(*storage).createNetworkTopology(NetworkTopology{}))
1145
				s.(*storage).baseDir = baseDir
1146
			},
1147
		},
1148
	}
1149

1150
	for _, tc := range tests {
1151
		t.Run(tc.name, func(t *testing.T) {
1152
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1153
			if err != nil {
1154
				t.Fatal(err)
1155
			}
1156

1157
			tc.mock(s)
1158
			tc.expect(t, s, tc.baseDir)
1159
			if err := s.ClearNetworkTopology(); err != nil {
1160
				t.Fatal(err)
1161
			}
1162
		})
1163
	}
1164
}
1165

1166
func TestStorage_openDownloadFile(t *testing.T) {
1167
	tests := []struct {
1168
		name       string
1169
		baseDir    string
1170
		maxSize    int
1171
		maxBackups int
1172

1173
		bufferSize int
1174
		mock       func(t *testing.T, s Storage)
1175
		expect     func(t *testing.T, s Storage, baseDir string)
1176
	}{
1177
		{
1178
			name:       "open file failed",
1179
			baseDir:    os.TempDir(),
1180
			maxSize:    config.DefaultStorageMaxSize,
1181
			maxBackups: config.DefaultStorageMaxBackups,
1182
			bufferSize: config.DefaultStorageBufferSize,
1183
			mock: func(t *testing.T, s Storage) {
1184
				s.(*storage).baseDir = "bat"
1185
			},
1186
			expect: func(t *testing.T, s Storage, baseDir string) {
1187
				assert := assert.New(t)
1188
				_, err := s.(*storage).openDownloadFile()
1189
				assert.Error(err)
1190
				s.(*storage).baseDir = baseDir
1191
			},
1192
		},
1193
		{
1194
			name:       "open new download file",
1195
			baseDir:    os.TempDir(),
1196
			maxSize:    0,
1197
			maxBackups: config.DefaultStorageMaxBackups,
1198
			bufferSize: 1,
1199
			mock: func(t *testing.T, s Storage) {
1200
				if err := s.CreateDownload(Download{ID: "1"}); err != nil {
1201
					t.Fatal(err)
1202
				}
1203

1204
				if err := s.CreateDownload(Download{ID: "2"}); err != nil {
1205
					t.Fatal(err)
1206
				}
1207
			},
1208
			expect: func(t *testing.T, s Storage, baseDir string) {
1209
				assert := assert.New(t)
1210
				file, err := s.(*storage).openDownloadFile()
1211
				assert.NoError(err)
1212
				assert.Equal(file.Name(), filepath.Join(baseDir, fmt.Sprintf("%s.%s", DownloadFilePrefix, CSVFileExt)))
1213
				file.Close()
1214
			},
1215
		},
1216
		{
1217
			name:       "remove download file",
1218
			baseDir:    os.TempDir(),
1219
			maxSize:    0,
1220
			maxBackups: 1,
1221
			bufferSize: 1,
1222
			mock: func(t *testing.T, s Storage) {
1223
				if err := s.CreateDownload(Download{ID: "1"}); err != nil {
1224
					t.Fatal(err)
1225
				}
1226
			},
1227
			expect: func(t *testing.T, s Storage, baseDir string) {
1228
				assert := assert.New(t)
1229
				file, err := s.(*storage).openDownloadFile()
1230
				assert.NoError(err)
1231
				assert.Equal(file.Name(), filepath.Join(baseDir, fmt.Sprintf("%s.%s", DownloadFilePrefix, CSVFileExt)))
1232
				file.Close()
1233
			},
1234
		},
1235
	}
1236

1237
	for _, tc := range tests {
1238
		t.Run(tc.name, func(t *testing.T) {
1239
			s, err := New(tc.baseDir, tc.maxSize, tc.maxBackups, tc.bufferSize)
1240
			if err != nil {
1241
				t.Fatal(err)
1242
			}
1243

1244
			tc.mock(t, s)
1245
			tc.expect(t, s, tc.baseDir)
1246
			if err := s.ClearDownload(); err != nil {
1247
				t.Fatal(err)
1248
			}
1249
		})
1250
	}
1251
}
1252

1253
func TestStorage_openNetworkTopologyFile(t *testing.T) {
1254
	tests := []struct {
1255
		name       string
1256
		baseDir    string
1257
		maxSize    int
1258
		maxBackups int
1259

1260
		bufferSize int
1261
		mock       func(t *testing.T, s Storage)
1262
		expect     func(t *testing.T, s Storage, baseDir string)
1263
	}{
1264
		{
1265
			name:       "open file failed",
1266
			baseDir:    os.TempDir(),
1267
			maxSize:    config.DefaultStorageMaxSize,
1268
			maxBackups: config.DefaultStorageMaxBackups,
1269
			bufferSize: config.DefaultStorageBufferSize,
1270
			mock: func(t *testing.T, s Storage) {
1271
				s.(*storage).baseDir = "bat"
1272
			},
1273
			expect: func(t *testing.T, s Storage, baseDir string) {
1274
				assert := assert.New(t)
1275
				_, err := s.(*storage).openNetworkTopologyFile()
1276
				assert.Error(err)
1277
				s.(*storage).baseDir = baseDir
1278
			},
1279
		},
1280
		{
1281
			name:       "open new network topology file",
1282
			baseDir:    os.TempDir(),
1283
			maxSize:    0,
1284
			maxBackups: config.DefaultStorageMaxBackups,
1285
			bufferSize: 1,
1286
			mock: func(t *testing.T, s Storage) {
1287
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "1"}); err != nil {
1288
					t.Fatal(err)
1289
				}
1290

1291
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "2"}); err != nil {
1292
					t.Fatal(err)
1293
				}
1294
			},
1295
			expect: func(t *testing.T, s Storage, baseDir string) {
1296
				assert := assert.New(t)
1297
				file, err := s.(*storage).openNetworkTopologyFile()
1298
				assert.NoError(err)
1299
				assert.Equal(file.Name(), filepath.Join(baseDir, fmt.Sprintf("%s.%s", NetworkTopologyFilePrefix, CSVFileExt)))
1300
				file.Close()
1301
			},
1302
		},
1303
		{
1304
			name:       "remove network topology file",
1305
			baseDir:    os.TempDir(),
1306
			maxSize:    0,
1307
			maxBackups: 1,
1308
			bufferSize: 1,
1309
			mock: func(t *testing.T, s Storage) {
1310
				if err := s.CreateNetworkTopology(NetworkTopology{ID: "1"}); err != nil {
1311
					t.Fatal(err)
1312
				}
1313
			},
1314
			expect: func(t *testing.T, s Storage, baseDir string) {
1315
				assert := assert.New(t)
1316
				file, err := s.(*storage).openNetworkTopologyFile()
1317
				assert.NoError(err)
1318
				assert.Equal(file.Name(), filepath.Join(baseDir, fmt.Sprintf("%s.%s", NetworkTopologyFilePrefix, CSVFileExt)))
1319
				file.Close()
1320
			},
1321
		},
1322
	}
1323

1324
	for _, tc := range tests {
1325
		t.Run(tc.name, func(t *testing.T) {
1326
			s, err := New(tc.baseDir, tc.maxSize, tc.maxBackups, tc.bufferSize)
1327
			if err != nil {
1328
				t.Fatal(err)
1329
			}
1330

1331
			tc.mock(t, s)
1332
			tc.expect(t, s, tc.baseDir)
1333
			if err := s.ClearNetworkTopology(); err != nil {
1334
				t.Fatal(err)
1335
			}
1336
		})
1337
	}
1338
}
1339

1340
func TestStorage_downloadBackupFilename(t *testing.T) {
1341
	baseDir := os.TempDir()
1342
	s, err := New(baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1343
	if err != nil {
1344
		t.Fatal(err)
1345
	}
1346

1347
	filename := s.(*storage).downloadBackupFilename()
1348
	regexp := regexp.MustCompile(fmt.Sprintf("%s_.*.%s$", DownloadFilePrefix, CSVFileExt))
1349
	assert := assert.New(t)
1350
	assert.True(regexp.MatchString(filename))
1351

1352
	if err := s.ClearDownload(); err != nil {
1353
		t.Fatal(err)
1354
	}
1355
}
1356

1357
func TestStorage_networkTopologyBackupFilename(t *testing.T) {
1358
	baseDir := os.TempDir()
1359
	s, err := New(baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1360
	if err != nil {
1361
		t.Fatal(err)
1362
	}
1363

1364
	filename := s.(*storage).networkTopologyBackupFilename()
1365
	regexp := regexp.MustCompile(fmt.Sprintf("%s_.*.%s$", NetworkTopologyFilePrefix, CSVFileExt))
1366
	assert := assert.New(t)
1367
	assert.True(regexp.MatchString(filename))
1368

1369
	if err := s.ClearNetworkTopology(); err != nil {
1370
		t.Fatal(err)
1371
	}
1372
}
1373

1374
func TestStorage_downloadBackups(t *testing.T) {
1375
	tests := []struct {
1376
		name    string
1377
		baseDir string
1378
		mock    func(t *testing.T, s Storage)
1379
		expect  func(t *testing.T, s Storage, baseDir string)
1380
	}{
1381
		{
1382
			name:    "open file failed",
1383
			baseDir: os.TempDir(),
1384
			mock: func(t *testing.T, s Storage) {
1385
				s.(*storage).baseDir = "bar"
1386
			},
1387
			expect: func(t *testing.T, s Storage, baseDir string) {
1388
				assert := assert.New(t)
1389
				_, err := s.(*storage).downloadBackups()
1390
				assert.Error(err)
1391
				s.(*storage).baseDir = baseDir
1392
				if err := s.ClearDownload(); err != nil {
1393
					t.Fatal(err)
1394
				}
1395
			},
1396
		},
1397
		{
1398
			name:    "not found download file",
1399
			baseDir: os.TempDir(),
1400
			mock:    func(t *testing.T, s Storage) {},
1401
			expect: func(t *testing.T, s Storage, baseDir string) {
1402
				assert := assert.New(t)
1403
				if err := s.ClearDownload(); err != nil {
1404
					t.Fatal(err)
1405
				}
1406

1407
				_, err := s.(*storage).downloadBackups()
1408
				assert.Error(err)
1409
			},
1410
		},
1411
	}
1412

1413
	for _, tc := range tests {
1414
		t.Run(tc.name, func(t *testing.T) {
1415
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1416
			if err != nil {
1417
				t.Fatal(err)
1418
			}
1419

1420
			tc.mock(t, s)
1421
			tc.expect(t, s, tc.baseDir)
1422
		})
1423
	}
1424
}
1425

1426
func TestStorage_networkTopologyBackups(t *testing.T) {
1427
	tests := []struct {
1428
		name    string
1429
		baseDir string
1430
		mock    func(t *testing.T, s Storage)
1431
		expect  func(t *testing.T, s Storage, baseDir string)
1432
	}{
1433
		{
1434
			name:    "open file failed",
1435
			baseDir: os.TempDir(),
1436
			mock: func(t *testing.T, s Storage) {
1437
				s.(*storage).baseDir = "bar"
1438
			},
1439
			expect: func(t *testing.T, s Storage, baseDir string) {
1440
				assert := assert.New(t)
1441
				_, err := s.(*storage).networkTopologyBackups()
1442
				assert.Error(err)
1443
				s.(*storage).baseDir = baseDir
1444
				if err := s.ClearNetworkTopology(); err != nil {
1445
					t.Fatal(err)
1446
				}
1447
			},
1448
		},
1449
		{
1450
			name:    "not found network topology file",
1451
			baseDir: os.TempDir(),
1452
			mock:    func(t *testing.T, s Storage) {},
1453
			expect: func(t *testing.T, s Storage, baseDir string) {
1454
				assert := assert.New(t)
1455
				if err := s.ClearNetworkTopology(); err != nil {
1456
					t.Fatal(err)
1457
				}
1458

1459
				_, err := s.(*storage).networkTopologyBackups()
1460
				assert.Error(err)
1461
			},
1462
		},
1463
	}
1464

1465
	for _, tc := range tests {
1466
		t.Run(tc.name, func(t *testing.T) {
1467
			s, err := New(tc.baseDir, config.DefaultStorageMaxSize, config.DefaultStorageMaxBackups, config.DefaultStorageBufferSize)
1468
			if err != nil {
1469
				t.Fatal(err)
1470
			}
1471

1472
			tc.mock(t, s)
1473
			tc.expect(t, s, tc.baseDir)
1474
		})
1475
	}
1476
}
1477