fork/gdu

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

Quet Zalfeat(analyze): add SQLite analyzer and some assorted changes (#484)da638da

subvolume
4.3 KiB174 linesraw
1package analyze
2
3import (
4	"archive/zip"
5	"os"
6	"path/filepath"
7	"slices"
8	"testing"
9
10	"github.com/dundee/gdu/v5/pkg/fs"
11	"github.com/stretchr/testify/assert"
12)
13
14func TestIsZipFile(t *testing.T) {
15	tests := []struct {
16		filename string
17		expected bool
18	}{
19		{"test.zip", true},
20		{"test.jar", true},
21		{"TEST.ZIP", true},
22		{"TEST.JAR", true},
23		{"test.txt", false},
24		{"test.tar.gz", false},
25		{"test", false},
26		{"", false},
27	}
28
29	for _, test := range tests {
30		result := isZipFile(test.filename)
31		assert.Equal(t, test.expected, result, "filename: %s", test.filename)
32	}
33}
34
35func TestProcessZipFile(t *testing.T) {
36	// Create temporary zip file
37	tempDir := t.TempDir()
38	zipPath := filepath.Join(tempDir, "test.zip")
39
40	// Create zip file
41	createTestZipFile(t, zipPath)
42
43	// Get file info
44	info, err := os.Stat(zipPath)
45	assert.NoError(t, err)
46
47	// Process zip file
48	zipDir, err := processZipFile(zipPath, info)
49	assert.NoError(t, err)
50	assert.NotNil(t, zipDir)
51
52	// Verify zip directory properties
53	assert.Equal(t, "test.zip", zipDir.GetName(), "Name must include extension")
54	assert.Equal(t, rune('Z'), zipDir.GetFlag())
55	assert.True(t, zipDir.IsDir())
56	assert.Equal(t, "ZipDirectory", zipDir.GetType())
57
58	// Verify file structure
59	files := slices.Collect(zipDir.GetFiles(fs.SortByName, fs.SortAsc))
60	assert.Greater(t, len(files), 0)
61
62	// Debug: print all files
63	t.Logf("Found %d files in zip:", len(files))
64	for _, file := range files {
65		t.Logf("  - %s (isDir: %t, type: %s)", file.GetName(), file.IsDir(), file.GetType())
66	}
67
68	// Find files
69	foundTextFile := false
70	foundSubdir := false
71
72	for _, file := range files {
73		if file.GetName() == "test.txt" {
74			foundTextFile = true
75			assert.False(t, file.IsDir())
76			assert.Equal(t, "ZipFile", file.GetType())
77		}
78		if file.GetName() == "subdir" {
79			foundSubdir = true
80			assert.True(t, file.IsDir())
81			assert.Equal(t, "ZipDirectory", file.GetType())
82		}
83	}
84
85	assert.True(t, foundTextFile, "should find test.txt file")
86	assert.True(t, foundSubdir, "should find subdir directory")
87}
88
89func TestGetZipFileSize(t *testing.T) {
90	// Create temporary zip file
91	tempDir := t.TempDir()
92	zipPath := filepath.Join(tempDir, "test.zip")
93
94	// Create zip file
95	createTestZipFile(t, zipPath)
96
97	// Get size
98	uncompressed, compressed, err := getZipFileSize(zipPath)
99	assert.NoError(t, err)
100	assert.Greater(t, uncompressed, int64(0))
101	assert.Greater(t, compressed, int64(0))
102	// Note: for small files, compressed size might be larger
103	t.Logf("Uncompressed size: %d, Compressed size: %d", uncompressed, compressed)
104}
105
106func TestEnsureZipDirExists(t *testing.T) {
107	tempDir := t.TempDir()
108	zipPath := filepath.Join(tempDir, "test.zip")
109
110	// Create root directory
111	rootDir := &ZipDir{
112		Dir: &Dir{
113			File: &File{
114				Name: "test.zip",
115				Flag: 'Z',
116			},
117			Files: make(fs.Files, 0),
118		},
119		zipPath: zipPath,
120	}
121
122	dirMap := make(map[string]*ZipDir)
123	dirMap[""] = rootDir
124
125	// Ensure nested directory structure is created
126	ensureZipDirExists(dirMap, "dir1/dir2/dir3", zipPath, rootDir)
127
128	// Verify directory structure
129	assert.Contains(t, dirMap, "dir1")
130	assert.Contains(t, dirMap, "dir1/dir2")
131	assert.Contains(t, dirMap, "dir1/dir2/dir3")
132
133	// Verify parent-child relationships
134	dir1 := dirMap["dir1"]
135	assert.Equal(t, rootDir, dir1.GetParent())
136
137	dir2 := dirMap["dir1/dir2"]
138	assert.Equal(t, dir1, dir2.GetParent())
139
140	dir3 := dirMap["dir1/dir2/dir3"]
141	assert.Equal(t, dir2, dir3.GetParent())
142}
143
144// createTestZipFile creates a test zip file
145func createTestZipFile(t *testing.T, zipPath string) {
146	file, err := os.Create(zipPath)
147	assert.NoError(t, err)
148	defer file.Close()
149
150	zipWriter := zip.NewWriter(file)
151	defer zipWriter.Close()
152
153	// Add root directory file
154	writer, err := zipWriter.Create("test.txt")
155	assert.NoError(t, err)
156	_, err = writer.Write([]byte("Hello, this is a test file!"))
157	assert.NoError(t, err)
158
159	// Add subdirectory files
160	// We don't need to use the writer for the directory entry, avoid SA4006
161	_, err = zipWriter.Create("subdir/")
162	assert.NoError(t, err)
163
164	writer, err = zipWriter.Create("subdir/nested.txt")
165	assert.NoError(t, err)
166	_, err = writer.Write([]byte("This is a nested file."))
167	assert.NoError(t, err)
168
169	// Add deeper directory structure
170	writer, err = zipWriter.Create("dir1/dir2/deep.txt")
171	assert.NoError(t, err)
172	_, err = writer.Write([]byte("Deep nested file content."))
173	assert.NoError(t, err)
174}