fork/gdu

git clone https://git.julia.blue/fork/gdu

ShivamB25feat: customize JSON export attributes (#605)d062e88

master
8.6 KiB382 linesraw
1package analyze
2
3import (
4	"archive/zip"
5	"bytes"
6	"os"
7	"path/filepath"
8	"testing"
9
10	"github.com/stretchr/testify/assert"
11)
12
13func TestZipFileGetPath(t *testing.T) {
14	zipFile := &ZipFile{
15		zipPath:   "/path/to/archive.zip",
16		inZipPath: "folder/file.txt",
17	}
18
19	path := zipFile.GetPath()
20	assert.Equal(t, "/path/to/archive.zip/folder/file.txt", path)
21}
22
23func TestZipFileEncodeJSON(t *testing.T) {
24	zipFile := &ZipFile{
25		File: &File{
26			Name: "test.txt",
27			Size: 100,
28		},
29		zipPath:   "/path/to/archive.zip",
30		inZipPath: "test.txt",
31	}
32
33	var buf bytes.Buffer
34	err := zipFile.EncodeJSON(&buf, false, nil)
35	assert.NoError(t, err)
36	assert.NotEmpty(t, buf.String())
37}
38
39func TestZipDirEncodeJSON(t *testing.T) {
40	zipDir := &ZipDir{
41		Dir: &Dir{
42			File: &File{
43				Name: "folder",
44			},
45		},
46		zipPath: "/path/to/archive.zip",
47	}
48
49	var buf bytes.Buffer
50	err := zipDir.EncodeJSON(&buf, false, nil)
51	assert.NoError(t, err)
52	assert.NotEmpty(t, buf.String())
53}
54
55func TestZipDirGetPathWithParent(t *testing.T) {
56	parent := &ZipDir{
57		Dir: &Dir{
58			File: &File{
59				Name: "parent",
60			},
61		},
62		zipPath: "/path/to/archive.zip",
63	}
64
65	zipDir := &ZipDir{
66		Dir: &Dir{
67			File: &File{
68				Name: "child",
69			},
70		},
71		zipPath: "/path/to/archive.zip",
72	}
73	zipDir.Parent = parent
74
75	path := zipDir.GetPath()
76	assert.Equal(t, filepath.Join(parent.GetPath(), "child"), path)
77}
78
79func TestZipDirGetPathWithoutParent(t *testing.T) {
80	zipDir := &ZipDir{
81		Dir: &Dir{
82			File: &File{
83				Name: "root",
84			},
85		},
86		zipPath: "/path/to/archive.zip",
87	}
88
89	path := zipDir.GetPath()
90	assert.Equal(t, "/path/to/archive.zip", path)
91}
92
93func TestProcessZipFileWithEmptyZip(t *testing.T) {
94	// Create a temporary zip file
95	zipPath := "/tmp/empty.zip"
96	defer os.Remove(zipPath)
97
98	// Create an empty zip file
99	file, err := os.Create(zipPath)
100	assert.NoError(t, err)
101	file.Close()
102
103	// Create a zip file with no entries
104	zipFile, err := os.Create(zipPath)
105	assert.NoError(t, err)
106	writer := zip.NewWriter(zipFile)
107	writer.Close()
108	zipFile.Close()
109
110	info, err := os.Stat(zipPath)
111	assert.NoError(t, err)
112
113	zipDir, err := processZipFile(zipPath, info)
114	assert.NoError(t, err)
115	assert.NotNil(t, zipDir)
116	assert.Equal(t, "empty.zip", zipDir.Name)
117	assert.Equal(t, 'Z', zipDir.Flag)
118}
119
120func TestProcessZipFileWithDirectoryEntries(t *testing.T) {
121	// Create a temporary zip file
122	zipPath := "/tmp/dir_entries.zip"
123	defer os.Remove(zipPath)
124
125	// Create a zip file with directory entries
126	zipFile, err := os.Create(zipPath)
127	assert.NoError(t, err)
128	writer := zip.NewWriter(zipFile)
129
130	// Add a directory entry
131	_, err = writer.Create("folder/")
132	assert.NoError(t, err)
133
134	// Add a file in the directory
135	fileWriter, err := writer.Create("folder/file.txt")
136	assert.NoError(t, err)
137	fileWriter.Write([]byte("test content"))
138
139	writer.Close()
140	zipFile.Close()
141
142	info, err := os.Stat(zipPath)
143	assert.NoError(t, err)
144
145	zipDir, err := processZipFile(zipPath, info)
146	assert.NoError(t, err)
147	assert.NotNil(t, zipDir)
148	assert.Equal(t, "dir_entries.zip", zipDir.Name)
149}
150
151func TestProcessZipFileWithNestedDirectories(t *testing.T) {
152	// Create a temporary zip file
153	zipPath := "/tmp/nested.zip"
154	defer os.Remove(zipPath)
155
156	// Create a zip file with nested directories
157	zipFile, err := os.Create(zipPath)
158	assert.NoError(t, err)
159	writer := zip.NewWriter(zipFile)
160
161	// Add files in nested directories
162	fileWriter, err := writer.Create("level1/level2/file.txt")
163	assert.NoError(t, err)
164	fileWriter.Write([]byte("nested content"))
165
166	writer.Close()
167	zipFile.Close()
168
169	info, err := os.Stat(zipPath)
170	assert.NoError(t, err)
171
172	zipDir, err := processZipFile(zipPath, info)
173	assert.NoError(t, err)
174	assert.NotNil(t, zipDir)
175	assert.Equal(t, "nested.zip", zipDir.Name)
176}
177
178func TestProcessZipFileWithRootFiles(t *testing.T) {
179	// Create a temporary zip file
180	zipPath := "/tmp/root_files.zip"
181	defer os.Remove(zipPath)
182
183	// Create a zip file with files in root
184	zipFile, err := os.Create(zipPath)
185	assert.NoError(t, err)
186	writer := zip.NewWriter(zipFile)
187
188	// Add files in root directory
189	fileWriter, err := writer.Create("file1.txt")
190	assert.NoError(t, err)
191	fileWriter.Write([]byte("file1 content"))
192
193	fileWriter, err = writer.Create("file2.txt")
194	assert.NoError(t, err)
195	fileWriter.Write([]byte("file2 content"))
196
197	writer.Close()
198	zipFile.Close()
199
200	info, err := os.Stat(zipPath)
201	assert.NoError(t, err)
202
203	zipDir, err := processZipFile(zipPath, info)
204	assert.NoError(t, err)
205	assert.NotNil(t, zipDir)
206	assert.Equal(t, "root_files.zip", zipDir.Name)
207}
208
209func TestProcessZipFileError(t *testing.T) {
210	// Test with non-existent file
211	zipDir, err := processZipFile("/non/existent/file.zip", nil)
212	assert.Error(t, err)
213	assert.Nil(t, zipDir)
214}
215
216func TestGetZipFileSizeWithEmptyZip(t *testing.T) {
217	// Create a temporary zip file
218	zipPath := "/tmp/empty_size.zip"
219	defer os.Remove(zipPath)
220
221	// Create an empty zip file
222	zipFile, err := os.Create(zipPath)
223	assert.NoError(t, err)
224	writer := zip.NewWriter(zipFile)
225	writer.Close()
226	zipFile.Close()
227
228	uncompressed, compressed, err := getZipFileSize(zipPath)
229	assert.NoError(t, err)
230	assert.Equal(t, int64(0), uncompressed)
231	assert.Equal(t, int64(0), compressed)
232}
233
234func TestGetZipFileSizeWithFiles(t *testing.T) {
235	// Create a temporary zip file
236	zipPath := "/tmp/size_test.zip"
237	defer os.Remove(zipPath)
238
239	// Create a zip file with files
240	zipFile, err := os.Create(zipPath)
241	assert.NoError(t, err)
242	writer := zip.NewWriter(zipFile)
243
244	// Add a file
245	fileWriter, err := writer.Create("test.txt")
246	assert.NoError(t, err)
247	fileWriter.Write([]byte("test content"))
248
249	writer.Close()
250	zipFile.Close()
251
252	uncompressed, compressed, err := getZipFileSize(zipPath)
253	assert.NoError(t, err)
254	assert.Greater(t, uncompressed, int64(0))
255	assert.Greater(t, compressed, int64(0))
256}
257
258func TestGetZipFileSizeWithDirectories(t *testing.T) {
259	// Create a temporary zip file
260	zipPath := "/tmp/dir_size.zip"
261	defer os.Remove(zipPath)
262
263	// Create a zip file with directories
264	zipFile, err := os.Create(zipPath)
265	assert.NoError(t, err)
266	writer := zip.NewWriter(zipFile)
267
268	// Add a directory entry (should be ignored)
269	_, err = writer.Create("folder/")
270	assert.NoError(t, err)
271
272	// Add a file
273	fileWriter, err := writer.Create("file.txt")
274	assert.NoError(t, err)
275	fileWriter.Write([]byte("test content"))
276
277	writer.Close()
278	zipFile.Close()
279
280	uncompressed, compressed, err := getZipFileSize(zipPath)
281	assert.NoError(t, err)
282	assert.Greater(t, uncompressed, int64(0))
283	assert.Greater(t, compressed, int64(0))
284}
285
286func TestGetZipFileSizeError(t *testing.T) {
287	// Test with non-existent file
288	uncompressed, compressed, err := getZipFileSize("/non/existent/file.zip")
289	assert.Error(t, err)
290	assert.Equal(t, int64(0), uncompressed)
291	assert.Equal(t, int64(0), compressed)
292}
293
294func TestEnsureZipDirExistsWithEmptyPath(t *testing.T) {
295	dirMap := make(map[string]*ZipDir)
296	rootDir := &ZipDir{
297		Dir: &Dir{
298			File: &File{
299				Name: "root",
300			},
301		},
302		zipPath: "/test.zip",
303	}
304
305	ensureZipDirExists(dirMap, "", "/test.zip", rootDir)
306	// Should not create any new directories for empty path
307	assert.Len(t, dirMap, 0)
308}
309
310func TestEnsureZipDirExistsWithDotPath(t *testing.T) {
311	dirMap := make(map[string]*ZipDir)
312	rootDir := &ZipDir{
313		Dir: &Dir{
314			File: &File{
315				Name: "root",
316			},
317		},
318		zipPath: "/test.zip",
319	}
320
321	ensureZipDirExists(dirMap, ".", "/test.zip", rootDir)
322	// Should not create any new directories for dot path
323	assert.Len(t, dirMap, 0)
324}
325
326func TestEnsureZipDirExistsWithExistingPath(t *testing.T) {
327	dirMap := make(map[string]*ZipDir)
328	existingDir := &ZipDir{
329		Dir: &Dir{
330			File: &File{
331				Name: "existing",
332			},
333		},
334		zipPath: "/test.zip",
335	}
336	dirMap["existing"] = existingDir
337
338	rootDir := &ZipDir{
339		Dir: &Dir{
340			File: &File{
341				Name: "root",
342			},
343		},
344		zipPath: "/test.zip",
345	}
346
347	ensureZipDirExists(dirMap, "existing", "/test.zip", rootDir)
348	// Should not create a new directory for existing path
349	assert.Len(t, dirMap, 1)
350	assert.Equal(t, existingDir, dirMap["existing"])
351}
352
353func TestEnsureZipDirExistsWithNestedPath(t *testing.T) {
354	dirMap := make(map[string]*ZipDir)
355	rootDir := &ZipDir{
356		Dir: &Dir{
357			File: &File{
358				Name: "root",
359			},
360		},
361		zipPath: "/test.zip",
362	}
363	dirMap[""] = rootDir
364
365	ensureZipDirExists(dirMap, "level1/level2", "/test.zip", rootDir)
366
367	// Should create both level1 and level1/level2 directories
368	assert.Contains(t, dirMap, "level1")
369	assert.Contains(t, dirMap, "level1/level2")
370	assert.Equal(t, "level1", dirMap["level1"].Name)
371	assert.Equal(t, "level2", dirMap["level1/level2"].Name)
372}
373
374func TestIsZipFileFunction(t *testing.T) {
375	assert.True(t, isZipFile("test.zip"))
376	assert.True(t, isZipFile("test.ZIP"))
377	assert.True(t, isZipFile("test.jar"))
378	assert.True(t, isZipFile("test.JAR"))
379	assert.False(t, isZipFile("test.txt"))
380	assert.False(t, isZipFile("test.tar"))
381	assert.False(t, isZipFile("test.gz"))
382}