1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
package directory
import (
"os"
"path/filepath"
"reflect"
"sort"
"testing"
)
// Usage of an empty directory should be 0
func TestUsageEmpty(t *testing.T) {
usage, _ := Usage(t.TempDir())
expectSizeAndInodeCount(t, "empty directory", usage, &DiskUsage{
Size: 0,
InodeCount: 1,
})
}
// Usage of one empty file should be 0
func TestUsageEmptyFile(t *testing.T) {
dir := t.TempDir()
var file *os.File
var err error
if file, err = os.CreateTemp(dir, "file"); err != nil {
t.Fatalf("failed to create file: %s", err)
}
usage, _ := Usage(file.Name())
expectSizeAndInodeCount(t, "one file", usage, &DiskUsage{
Size: 0,
InodeCount: 1,
})
}
// Usage of a directory with one 5-byte file should be 5
func TestUsageNonemptyFile(t *testing.T) {
dir := t.TempDir()
var file *os.File
var err error
if file, err = os.CreateTemp(dir, "file"); err != nil {
t.Fatalf("failed to create file: %s", err)
}
d := []byte{97, 98, 99, 100, 101}
file.Write(d)
usage, _ := Usage(dir)
expectSizeAndInodeCount(t, "directory with one 5-byte file", usage, &DiskUsage{
Size: 5,
InodeCount: 2,
})
}
// Usage of an empty directory should be 0
func TestUsageEmptyDirectory(t *testing.T) {
usage, _ := Usage(t.TempDir())
expectSizeAndInodeCount(t, "one directory", usage, &DiskUsage{
Size: 0,
InodeCount: 1,
})
}
// Usage of a directory with one empty directory should be 0
func TestUsageNestedDirectoryEmpty(t *testing.T) {
dir := t.TempDir()
if _, err := os.MkdirTemp(dir, "nested"); err != nil {
t.Fatalf("failed to create nested directory: %s", err)
}
usage, _ := Usage(dir)
expectSizeAndInodeCount(t, "directory with one empty directory", usage, &DiskUsage{
Size: 0,
InodeCount: 2,
})
}
// Test directory with 1 file and 1 empty directory
func TestUsageFileAndNestedDirectoryEmpty(t *testing.T) {
var err error
dir := t.TempDir()
if _, err = os.MkdirTemp(dir, "nested"); err != nil {
t.Fatalf("failed to create nested directory: %s", err)
}
var file *os.File
if file, err = os.CreateTemp(dir, "file"); err != nil {
t.Fatalf("failed to create file: %s", err)
}
d := []byte{100, 111, 99, 107, 101, 114}
file.Write(d)
usage, _ := Usage(dir)
expectSizeAndInodeCount(t, "directory with 6-byte file and empty directory", usage, &DiskUsage{
Size: 6,
InodeCount: 3,
})
}
// Test directory with 1 file and 1 non-empty directory
func TestUsageFileAndNestedDirectoryNonempty(t *testing.T) {
var dirNested string
var err error
dir := t.TempDir()
if dirNested, err = os.MkdirTemp(dir, "nested"); err != nil {
t.Fatalf("failed to create nested directory: %s", err)
}
var file *os.File
if file, err = os.CreateTemp(dir, "file"); err != nil {
t.Fatalf("failed to create file: %s", err)
}
data := []byte{100, 111, 99, 107, 101, 114}
file.Write(data)
var nestedFile *os.File
if nestedFile, err = os.CreateTemp(dirNested, "file"); err != nil {
t.Fatalf("failed to create file in nested directory: %s", err)
}
nestedData := []byte{100, 111, 99, 107, 101, 114}
nestedFile.Write(nestedData)
usage, _ := Usage(dir)
expectSizeAndInodeCount(t, "directory with 6-byte file and nested directory with 6-byte file", usage, &DiskUsage{
Size: 12,
InodeCount: 4,
})
}
// Test migration of directory to a subdir underneath itself
func TestMoveToSubdir(t *testing.T) {
var subDir string
var err error
outerDir := t.TempDir()
if subDir, err = os.MkdirTemp(outerDir, "testSub"); err != nil {
t.Fatalf("failed to create subdirectory: %v", err)
}
// write 4 temp files in the outer dir to get moved
filesList := []string{"a", "b", "c", "d"}
for _, fName := range filesList {
if file, err := os.Create(filepath.Join(outerDir, fName)); err != nil {
t.Fatalf("couldn't create temp file %q: %v", fName, err)
} else {
file.WriteString(fName)
file.Close()
}
}
if err = MoveToSubdir(outerDir, filepath.Base(subDir)); err != nil {
t.Fatalf("Error during migration of content to subdirectory: %v", err)
}
// validate that the files were moved to the subdirectory
infos, err := os.ReadDir(subDir)
if err != nil {
t.Fatal(err)
}
if len(infos) != 4 {
t.Fatalf("Should be four files in the subdir after the migration: actual length: %d", len(infos))
}
var results []string
for _, info := range infos {
results = append(results, info.Name())
}
sort.Strings(results)
if !reflect.DeepEqual(filesList, results) {
t.Fatalf("Results after migration do not equal list of files: expected: %v, got: %v", filesList, results)
}
}
// Test a non-existing directory
func TestUsageNonExistingDirectory(t *testing.T) {
if _, err := Usage("/thisdirectoryshouldnotexist/TestUsageNonExistingDirectory"); err == nil {
t.Fatalf("error is expected")
}
}
// A helper function that tests expectation of inode count and dir size against
// the found usage.
func expectSizeAndInodeCount(t *testing.T, testName string, current, expected *DiskUsage) {
if current.Size != expected.Size {
t.Errorf("%s has size: %d, expected %d", testName, current.Size, expected.Size)
}
if current.InodeCount != expected.InodeCount {
t.Errorf("%s has inode count: %d, expected %d", testName, current.InodeCount, expected.InodeCount)
}
}
|
