wal-g

1
package internal_test
2

3
import (
4
	"bytes"
5
	"testing"
6
	"time"
7

8
	"github.com/stretchr/testify/assert"
9
	"github.com/wal-g/wal-g/internal"
10
	"github.com/wal-g/wal-g/pkg/storages/memory"
11
	"github.com/wal-g/wal-g/pkg/storages/storage"
12
	"github.com/wal-g/wal-g/testtools"
13
	"github.com/wal-g/wal-g/utility"
14
)
15

16
var (
17
	testStreamBackup = internal.BackupTime{
18
		BackupName: "stream_20210329T125616Z",
19
		Time:       time.Now(),
20
	}
21
)
22

23
func TestGetBackups_emptyFolder(t *testing.T) {
24
	folder := testtools.MakeDefaultInMemoryStorageFolder()
25
	_ = folder.PutObject("base_123312", &bytes.Buffer{})
26

27
	backups, err := internal.GetBackups(folder)
28

29
	assert.Empty(t, backups)
30
	assert.Error(t, err, internal.NoBackupsFoundError{})
31
}
32

33
func TestGetBackups(t *testing.T) {
34
	folder := testtools.MakeDefaultInMemoryStorageFolder()
35
	_ = folder.PutObject("base_123312", &bytes.Buffer{})
36
	_ = folder.PutObject(testStreamBackup.BackupName+utility.SentinelSuffix, &bytes.Buffer{})
37

38
	backups, _ := internal.GetBackups(folder)
39

40
	assert.Equal(t, 1, len(backups))
41
	assert.Equal(t, testStreamBackup.BackupName, backups[0].BackupName)
42
}
43

44
func TestGetBackupsAndGarbage_emptyList(t *testing.T) {
45
	folder := testtools.MakeDefaultInMemoryStorageFolder()
46
	_ = folder.PutObject("base_123312", &bytes.Buffer{})
47

48
	backups, garbage, _ := internal.GetBackupsAndGarbage(folder)
49

50
	assert.Empty(t, backups)
51
	assert.Empty(t, garbage)
52
}
53

54
func TestGetBackupsAndGarbage(t *testing.T) {
55
	folder := testtools.MakeDefaultInMemoryStorageFolder()
56
	_ = folder.PutObject("base_123312", &bytes.Buffer{})
57
	_ = folder.PutObject("base_321/nop", &bytes.Buffer{})
58
	_ = folder.PutObject(testStreamBackup.BackupName+utility.SentinelSuffix, &bytes.Buffer{})
59

60
	backups, garbage, _ := internal.GetBackupsAndGarbage(folder)
61

62
	assert.Equal(t, 1, len(backups))
63
	assert.Equal(t, 1, len(garbage))
64
	assert.Equal(t, testStreamBackup.BackupName, backups[0].BackupName)
65
	assert.Equal(t, "base_321", garbage[0])
66
}
67

68
func TestGetBackupTimeSlices_emptyList(t *testing.T) {
69
	folder := testtools.MakeDefaultInMemoryStorageFolder()
70
	_ = folder.PutObject("base_123312", &bytes.Buffer{})
71
	objects, _, _ := folder.ListFolder()
72
	result := internal.GetBackupTimeSlices(objects)
73
	assert.Equalf(t, []internal.BackupTime{}, result, "GetBackupTimeSlices returned not empty list: something wrong")
74
}
75

76
func TestGetBackupTimeSlices_List(t *testing.T) {
77
	folder := testtools.MakeDefaultInMemoryStorageFolder()
78
	_ = folder.PutObject("base_123312", &bytes.Buffer{})
79
	_ = folder.PutObject(testStreamBackup.BackupName+utility.SentinelSuffix, &bytes.Buffer{})
80

81
	objects, _, _ := folder.ListFolder()
82

83
	result := internal.GetBackupTimeSlices(objects)
84

85
	assert.Equalf(t, 1, len(result), "GetBackupTimeSlices returned wrong count of backup: something wrong")
86
	assert.Equalf(t, testStreamBackup.BackupName, result[0].BackupName, "GetBackupTimeSlices returned strange name")
87
	assert.True(t, testStreamBackup.Time.Before(result[0].Time), "GetBackupTimeSlices returned bad time: storage time less than mock time")
88
}
89

90
func TestGetBackupTimeSlices_OrderCheck(t *testing.T) {
91
	folder := testtools.MakeDefaultInMemoryStorageFolder()
92
	_ = folder.PutObject(testStreamBackup.BackupName+".1"+utility.SentinelSuffix, &bytes.Buffer{})
93
	time.Sleep(time.Second)
94
	_ = folder.PutObject(testStreamBackup.BackupName+".2"+utility.SentinelSuffix, &bytes.Buffer{})
95

96
	objects, _, _ := folder.ListFolder()
97

98
	result := internal.GetBackupTimeSlices(objects)
99
	internal.SortBackupTimeSlices(result)
100

101
	assert.Equalf(t, 2, len(result), "GetBackupTimeSlices returned wrong count of backup: something wrong")
102
	assert.True(t, result[0].BackupName == testStreamBackup.BackupName+".1", "GetBackupTimeSlices returned bad time ordering: "+testStreamBackup.BackupName+".1 should be first, because second was added earlier")
103
	assert.True(t, result[0].Time.Before(result[1].Time), "GetBackupTimeSlices returned bad time ordering: order should be Ascending")
104
}
105

106
func TestGetLastBackupName(t *testing.T) {
107
	folder := testtools.MakeDefaultInMemoryStorageFolder()
108
	b1 := testStreamBackup.BackupName + ".1" + utility.SentinelSuffix
109
	b2 := testStreamBackup.BackupName + ".2" + utility.SentinelSuffix
110
	_, _ = folder.PutObject(b1, &bytes.Buffer{}), folder.PutObject(b2, &bytes.Buffer{})
111
	lastB, _ := internal.GetLatestBackup(folder)
112
	assert.Equalf(t, lastB.Name+utility.SentinelSuffix, b2, "Last Backup is not b2")
113
}
114

115
func TestGetLatestBackupName_EmptyWhenNoBackups(t *testing.T) {
116
	folder := testtools.MakeDefaultInMemoryStorageFolder()
117
	lastB, _ := internal.GetLatestBackup(folder)
118
	assert.Equal(t, "", lastB.Name)
119
}
120

121
func TestGetGarbageFromPrefix(t *testing.T) {
122
	backupNames := []string{"backup", "garbage", "garbage_0"}
123
	folders := make([]storage.Folder, 0)
124
	nonGarbage := []internal.BackupTime{{BackupName: "backup", Time: time.Now(), WalFileName: "ZZZZZZZZZZZZZZZZZZZZZZZZ"}}
125

126
	for _, prefix := range backupNames {
127
		folders = append(folders, memory.NewFolder(prefix, memory.NewKVS()))
128
	}
129

130
	garbage := internal.GetGarbageFromPrefix(folders, nonGarbage)
131
	assert.Equal(t, garbage, []string{"garbage", "garbage_0"})
132
}
133

134
func TestGetGarbageFromPrefix_emptyNonGarbage(t *testing.T) {
135
	backupNames := []string{"backup", "garbage", "garbage_0"}
136
	folders := make([]storage.Folder, 0)
137
	nonGarbage := make([]internal.BackupTime, 0)
138

139
	for _, prefix := range backupNames {
140
		folders = append(folders, memory.NewFolder(prefix, memory.NewKVS()))
141
	}
142

143
	garbage := internal.GetGarbageFromPrefix(folders, nonGarbage)
144
	assert.Equal(t, garbage, []string{"backup", "garbage", "garbage_0"})
145
}
146

147
func TestGetGarbageFromPrefix_emptyFolders(t *testing.T) {
148
	folders := make([]storage.Folder, 0)
149
	nonGarbage := make([]internal.BackupTime, 0)
150

151
	garbage := internal.GetGarbageFromPrefix(folders, nonGarbage)
152
	assert.Equal(t, garbage, make([]string, 0))
153
}
154

155
func TestDeleteGarbage_emptyFolder(t *testing.T) {
156

157
	folder := testtools.MakeDefaultInMemoryStorageFolder()
158

159
	objects, folders, _ := folder.ListFolder()
160
	assert.Equal(t, 0, len(objects))
161
	assert.Equal(t, 0, len(folders))
162

163
	err := internal.DeleteGarbage(folder, []string{"backup1", "backup2", "backup3"})
164
	assert.Equal(t, nil, err)
165

166
	objects, folders, _ = folder.ListFolder()
167
	assert.Equal(t, 0, len(objects))
168
	assert.Equal(t, 0, len(folders))
169
}
170

171
func TestDeleteGarbage_nonRecursive(t *testing.T) {
172
	folder := testtools.MakeDefaultInMemoryStorageFolder()
173
	_ = folder.PutObject("backup1/file.json", &bytes.Buffer{})
174
	_ = folder.PutObject("backup2/file.json", &bytes.Buffer{})
175

176
	objects, folders, _ := folder.ListFolder()
177
	assert.Equal(t, 0, len(objects))
178
	assert.Equal(t, 2, len(folders))
179

180
	err := internal.DeleteGarbage(folder, []string{"backup1"})
181
	assert.Equal(t, nil, err)
182

183
	objects, folders, _ = folder.ListFolder()
184
	assert.Equal(t, 0, len(objects))
185
	assert.Equal(t, 1, len(folders))
186
	assert.Equal(t, folders[0].GetPath(), "in_memory/backup2/")
187
}
188

189
func TestDeleteGarbage_recursive(t *testing.T) {
190
	folder := testtools.MakeDefaultInMemoryStorageFolder()
191
	_ = folder.PutObject("backup1/folder1/obj1.tar", &bytes.Buffer{})
192
	_ = folder.PutObject("backup1/folder2/obj2.zip", &bytes.Buffer{})
193
	_ = folder.PutObject("backup1/meta.json", &bytes.Buffer{})
194
	_ = folder.PutObject("backup2/meta_b2.json", &bytes.Buffer{})
195
	_ = folder.PutObject("backup2/folder1/obj1.tar", &bytes.Buffer{})
196

197
	objects, folders, _ := folder.ListFolder()
198
	assert.Equal(t, 0, len(objects))
199
	assert.Equal(t, 2, len(folders))
200

201
	err := internal.DeleteGarbage(folder, []string{"backup1"})
202
	assert.Equal(t, nil, err)
203

204
	objects, folders, _ = folder.ListFolder()
205
	assert.Equal(t, 0, len(objects))
206
	assert.Equal(t, 1, len(folders))
207
	backup2 := folders[0]
208
	assert.Equal(t, backup2.GetPath(), "in_memory/backup2/")
209
	objects, folders, _ = backup2.ListFolder()
210
	assert.Equal(t, 1, len(objects))
211
	assert.Equal(t, 1, len(folders))
212
	assert.Equal(t, objects[0].GetName(), "meta_b2.json")
213
	assert.Equal(t, folders[0].GetPath(), "in_memory/backup2/folder1/")
214

215
}
216