fork/gdu

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

ShivamB25feat: stop scanning and keep partial results (#606)99a7f2a

subvolume
4.7 KiB164 linesraw
1package analyze
2
3import (
4	"os"
5	"path/filepath"
6	"testing"
7	"time"
8
9	"github.com/dundee/gdu/v5/internal/common"
10	"github.com/dundee/gdu/v5/pkg/fs"
11	"github.com/stretchr/testify/assert"
12)
13
14func TestAnalyzersCancelKeepsPartialResults(t *testing.T) {
15	root := createCancellationTree(t)
16
17	tests := []struct {
18		name     string
19		analyzer common.Analyzer
20	}{
21		{name: "parallel", analyzer: CreateAnalyzer()},
22		{name: "stable parallel", analyzer: CreateStableOrderAnalyzer()},
23		{name: "sequential", analyzer: CreateSeqAnalyzer()},
24	}
25
26	for _, test := range tests {
27		t.Run(test.name, func(t *testing.T) {
28			dir := scanUntilCancelled(t, test.analyzer, root)
29
30			assert.True(t, test.analyzer.(interface{ IsCancelled() bool }).IsCancelled())
31			assert.Contains(t, itemNames(dir), "a-file")
32			assert.NotContains(t, itemNames(dir), "b-dir")
33		})
34	}
35}
36
37func TestParallelAnalyzersCancelQueuedDirectories(t *testing.T) {
38	root := createCancellationTree(t)
39	tests := []struct {
40		name    string
41		factory func() common.Analyzer
42	}{
43		{name: "parallel", factory: func() common.Analyzer { return CreateAnalyzer() }},
44		{name: "stable parallel", factory: func() common.Analyzer { return CreateStableOrderAnalyzer() }},
45	}
46
47	for _, test := range tests {
48		t.Run(test.name, func(t *testing.T) {
49			initialSlots := len(concurrencyLimit)
50			for len(concurrencyLimit) < cap(concurrencyLimit) {
51				concurrencyLimit <- struct{}{}
52			}
53			defer func() {
54				for len(concurrencyLimit) > initialSlots {
55					<-concurrencyLimit
56				}
57			}()
58
59			analyzer := test.factory()
60			result := make(chan fs.Item, 1)
61			go func() {
62				result <- analyzer.AnalyzeDir(root, func(_, _ string) bool { return false }, nil)
63			}()
64
65			assert.Eventually(t, func() bool {
66				return analyzer.GetProgress().CurrentItemName == root
67			}, time.Second, time.Millisecond)
68			analyzer.Cancel()
69			<-concurrencyLimit
70
71			select {
72			case dir := <-result:
73				assert.NotContains(t, itemNames(dir), "b-dir")
74			case <-time.After(time.Second):
75				t.Fatal("analyzer did not discard queued directory after cancellation")
76			}
77		})
78	}
79}
80
81func TestStorageBackedAnalyzersCancelKeepsPartialResults(t *testing.T) {
82	root := createCancellationTree(t)
83
84	stored := CreateStoredAnalyzer(filepath.Join(t.TempDir(), "results.badger"))
85	dir := scanUntilCancelled(t, stored, root)
86	assert.True(t, stored.IsCancelled())
87	assert.Contains(t, itemNames(dir), "a-file")
88	assert.NotContains(t, itemNames(dir), "b-dir")
89
90	sqliteAnalyzer, err := CreateSqliteAnalyzer(filepath.Join(t.TempDir(), "results.sqlite"))
91	assert.NoError(t, err)
92	defer sqliteAnalyzer.storage.Close()
93	dir = scanUntilCancelled(t, sqliteAnalyzer, root)
94	assert.True(t, sqliteAnalyzer.IsCancelled())
95	assert.Contains(t, itemNames(dir), "a-file")
96	assert.NotContains(t, itemNames(dir), "b-dir")
97}
98
99func TestAnalyzeDirHonorsPreemptiveCancellation(t *testing.T) {
100	analyzer := CreateSeqAnalyzer()
101	analyzer.Cancel()
102
103	dir := analyzer.AnalyzeDir(createCancellationTree(t), func(_, _ string) bool { return false }, nil)
104
105	assert.True(t, analyzer.IsCancelled())
106	assert.NotContains(t, itemNames(dir), "a-file")
107	assert.NotContains(t, itemNames(dir), "b-dir")
108}
109
110func TestResetProgressClearsPreviousCancellation(t *testing.T) {
111	analyzer := CreateSeqAnalyzer()
112	analyzer.Cancel()
113	analyzer.ResetProgress()
114
115	dir := analyzer.AnalyzeDir(createCancellationTree(t), func(_, _ string) bool { return false }, nil)
116
117	assert.False(t, analyzer.IsCancelled())
118	assert.Contains(t, itemNames(dir), "a-file")
119	assert.Contains(t, itemNames(dir), "b-dir")
120}
121
122func TestTopDirAnalyzerCancellationStopsActiveSubdirectory(t *testing.T) {
123	root := t.TempDir()
124	assert.NoError(t, os.WriteFile(filepath.Join(root, "unscanned"), []byte("data"), 0o600))
125
126	analyzer := CreateTopDirAnalyzer()
127	t.Cleanup(analyzer.progressTicker.Stop)
128	analyzer.Cancel()
129	result := &TopDir{}
130
131	analyzer.processSubDir(root, result)
132
133	size, usage, itemCount := result.GetUsage()
134	assert.Zero(t, size)
135	assert.Zero(t, usage)
136	assert.Zero(t, itemCount)
137}
138
139func createCancellationTree(t *testing.T) string {
140	t.Helper()
141	root := t.TempDir()
142	assert.NoError(t, os.WriteFile(filepath.Join(root, "a-file"), []byte("complete"), 0o600))
143	assert.NoError(t, os.Mkdir(filepath.Join(root, "b-dir"), 0o700))
144	assert.NoError(t, os.WriteFile(filepath.Join(root, "b-dir", "nested"), []byte("pending"), 0o600))
145	return root
146}
147
148func scanUntilCancelled(t *testing.T, analyzer common.Analyzer, root string) fs.Item {
149	t.Helper()
150	return analyzer.AnalyzeDir(root, func(name, _ string) bool {
151		if name == "b-dir" {
152			analyzer.Cancel()
153		}
154		return false
155	}, nil)
156}
157
158func itemNames(dir fs.Item) []string {
159	var names []string
160	for item := range dir.GetFiles(fs.SortByName, fs.SortAsc) {
161		names = append(names, item.GetName())
162	}
163	return names
164}