clawbot
2125a9d451
check / check (push) Waiting to run
Every backup queued every directory and symlink for the second phase. The line ending the walk counted directories, and their stat sizes, as files to back up while its enumerated count left them out, and a symlink was counted as backed up on every run, its target length as data. The walk now sets directories aside: they are recorded before the files are backed up and never counted as files or data, and the walk's progress estimate leaves out the directories the local index knows. A symlink is checked against its record like a regular file, its target included, so an unchanged one counts as unchanged. Judgement call: every directory is still written to the local index on every backup, as before; no report shows it. Model: opus-5-5
94 lines
2.4 KiB
Go
94 lines
2.4 KiB
Go
package snapshot_test
|
|
|
|
import (
|
|
"context"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/spf13/afero"
|
|
"sneak.berlin/go/vaultik/internal/database"
|
|
"sneak.berlin/go/vaultik/internal/snapshot"
|
|
)
|
|
|
|
// TestProgressPercentWithSecondPathSmaller backs up two paths with one
|
|
// scanner, as a snapshot with two paths does, the second path smaller
|
|
// than the first. The progress line divides the bytes processed by the
|
|
// total size, so both must count both paths to stay within 100%.
|
|
func TestProgressPercentWithSecondPathSmaller(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string]string{
|
|
"/large/one.txt": strings.Repeat("1", 4000),
|
|
"/large/two.txt": strings.Repeat("2", 4000),
|
|
"/small/three.txt": strings.Repeat("3", 1000),
|
|
}
|
|
|
|
for path, content := range files {
|
|
err := fs.MkdirAll(filepath.Dir(path), 0755)
|
|
if err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
err = afero.WriteFile(fs, path, []byte(content), 0644)
|
|
if err != nil {
|
|
t.Fatalf("write %s: %v", path, err)
|
|
}
|
|
}
|
|
|
|
db, err := database.NewTestDB()
|
|
if err != nil {
|
|
t.Fatalf("create test db: %v", err)
|
|
}
|
|
|
|
t.Cleanup(func() {
|
|
cerr := db.Close()
|
|
if cerr != nil {
|
|
t.Errorf("close db: %v", cerr)
|
|
}
|
|
})
|
|
|
|
repos := database.NewRepositories(db)
|
|
|
|
scanner := snapshot.NewScanner(snapshot.ScannerConfig{
|
|
FS: fs,
|
|
ChunkSize: int64(1024 * 16),
|
|
Repositories: repos,
|
|
MaxBlobSize: int64(1024 * 1024),
|
|
CompressionLevel: 3,
|
|
AgeRecipients: []string{testAgePublicKey},
|
|
EnableProgress: true,
|
|
})
|
|
|
|
// Never started, but Stop releases its tickers and signal handler.
|
|
progress := scanner.GetProgress()
|
|
defer progress.Stop()
|
|
|
|
ctx := context.Background()
|
|
snapshotID := "test-snapshot-progress"
|
|
createTestSnapshotRecord(ctx, t, repos, snapshotID)
|
|
|
|
for _, path := range []string{"/large", "/small"} {
|
|
_, err := scanner.Scan(ctx, path, snapshotID)
|
|
if err != nil {
|
|
t.Fatalf("scanning %s: %v", path, err)
|
|
}
|
|
}
|
|
|
|
stats := progress.GetStats()
|
|
|
|
// With both paths counted, the percentage must not exceed 100%.
|
|
percent := float64(stats.BytesProcessed.Load()) /
|
|
float64(stats.TotalSize.Load()) * 100
|
|
if percent > 100 {
|
|
t.Errorf("progress after both paths is %.1f%%, want at most 100%%",
|
|
percent)
|
|
}
|
|
|
|
if stats.FilesProcessed.Load() != stats.TotalFiles.Load() {
|
|
t.Errorf("progress after both paths is %d of %d files, want all",
|
|
stats.FilesProcessed.Load(), stats.TotalFiles.Load())
|
|
}
|
|
}
|