sneak
9158721425
check / check (push) Failing after 2s
NewChecker now takes *CheckerOptions (ManifestPath, BasePath, Fs), named like ScannerOptions. A nil Fs still means the OS filesystem, as before and as in ScannerOptions; nil options or an empty path return an error naming the missing path. Audit of the other exported constructors in mfer: NewManifestFromFile took a filesystem and a path positionally; it now takes *ManifestFromFileOptions (Path, Fs) with the same nil and empty rules. NewBuilder and NewScanner take no arguments, NewScannerWithOptions already takes options, and NewManifestFromReader takes one reader, which the style guide exempts; these are unchanged. Model: opus-5-5
794 lines
20 KiB
Go
794 lines
20 KiB
Go
//nolint:testpackage // white-box tests exercise unexported internals
|
|
package mfer
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/spf13/afero"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
const (
|
|
testFile1 = "file1.txt"
|
|
testFile2 = "file2.txt"
|
|
testExistsFile = "exists.txt"
|
|
testManifestPath = "/manifest.mf"
|
|
testDataDir = "/data"
|
|
)
|
|
|
|
func TestStatusString(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
status Status
|
|
expected string
|
|
}{
|
|
{StatusOK, "OK"},
|
|
{StatusMissing, "MISSING"},
|
|
{StatusSizeMismatch, "SIZE_MISMATCH"},
|
|
{StatusHashMismatch, "HASH_MISMATCH"},
|
|
{StatusExtra, "EXTRA"},
|
|
{StatusError, "ERROR"},
|
|
{Status(99), "UNKNOWN"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.expected, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
assert.Equal(t, tt.expected, tt.status.String())
|
|
})
|
|
}
|
|
}
|
|
|
|
// createTestManifest creates a manifest file in the filesystem with the given files.
|
|
func createTestManifest(
|
|
t *testing.T, fs afero.Fs, manifestPath string, files map[string][]byte,
|
|
) {
|
|
t.Helper()
|
|
|
|
builder := NewBuilder()
|
|
|
|
for path, content := range files {
|
|
reader := bytes.NewReader(content)
|
|
_, err := builder.AddFile(
|
|
RelFilePath(path), FileSize(len(content)), ModTime(time.Now()), reader, nil,
|
|
)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
require.NoError(t, builder.Build(context.Background(), &buf))
|
|
require.NoError(t, afero.WriteFile(fs, manifestPath, buf.Bytes(), 0o644))
|
|
}
|
|
|
|
// createFilesOnDisk creates the given files on the filesystem under
|
|
// testDataDir.
|
|
func createFilesOnDisk(t *testing.T, fs afero.Fs, files map[string][]byte) {
|
|
t.Helper()
|
|
|
|
for path, content := range files {
|
|
fullPath := testDataDir + "/" + path
|
|
require.NoError(t, fs.MkdirAll(testDataDir, 0o755))
|
|
require.NoError(t, afero.WriteFile(fs, fullPath, content, 0o644))
|
|
}
|
|
}
|
|
|
|
func TestNewChecker(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("valid manifest", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testFile1: []byte("hello"),
|
|
testFile2: []byte("world"),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: "/",
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, chk)
|
|
assert.Equal(t, FileCount(2), chk.FileCount())
|
|
})
|
|
|
|
t.Run("missing manifest", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
_, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: "/nonexistent.mf",
|
|
BasePath: "/",
|
|
Fs: fs,
|
|
})
|
|
assert.Error(t, err)
|
|
})
|
|
|
|
t.Run("invalid manifest", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
require.NoError(t, afero.WriteFile(fs, "/bad.mf", []byte("not a manifest"), 0o644))
|
|
_, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: "/bad.mf",
|
|
BasePath: "/",
|
|
Fs: fs,
|
|
})
|
|
assert.Error(t, err)
|
|
})
|
|
}
|
|
|
|
func TestNewCheckerRequiredPaths(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
opts *CheckerOptions
|
|
want string
|
|
is error
|
|
}{
|
|
{
|
|
name: "nil options",
|
|
opts: nil,
|
|
want: "manifest path cannot be empty",
|
|
is: errManifestPathEmpty,
|
|
},
|
|
{
|
|
name: "empty manifest path",
|
|
opts: &CheckerOptions{BasePath: testDataDir},
|
|
want: "manifest path cannot be empty",
|
|
is: errManifestPathEmpty,
|
|
},
|
|
{
|
|
name: "empty base path",
|
|
opts: &CheckerOptions{ManifestPath: testManifestPath},
|
|
want: "base path cannot be empty",
|
|
is: errBasePathEmpty,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
chk, err := NewChecker(tc.opts)
|
|
require.ErrorIs(t, err, tc.is)
|
|
require.EqualError(t, err, tc.want)
|
|
assert.Nil(t, chk)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNewCheckerNilFsUsesOsFs(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
manifestPath := filepath.Join(dir, "index.mf")
|
|
content := []byte("hello")
|
|
createTestManifest(t, afero.NewOsFs(), manifestPath, map[string][]byte{
|
|
testFile1: content,
|
|
})
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, testFile1), content, 0o600))
|
|
|
|
chk, err := NewChecker(&CheckerOptions{ManifestPath: manifestPath, BasePath: dir})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 1)
|
|
require.NoError(t, chk.Check(context.Background(), results, nil))
|
|
assert.Equal(t, StatusOK, (<-results).Status)
|
|
}
|
|
|
|
func TestCheckerFileCountAndTotalBytes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
"small.txt": []byte("hi"),
|
|
"medium.txt": []byte("hello world"),
|
|
"large.txt": bytes.Repeat([]byte("x"), 1000),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: "/",
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, FileCount(3), chk.FileCount())
|
|
assert.Equal(t, FileSize(2+11+1000), chk.TotalBytes())
|
|
}
|
|
|
|
func TestCheckAllFilesOK(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testFile1: []byte("content one"),
|
|
testFile2: []byte("content two"),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.Check(context.Background(), results, nil)
|
|
require.NoError(t, err)
|
|
|
|
var resultList []Result
|
|
for r := range results {
|
|
resultList = append(resultList, r)
|
|
}
|
|
|
|
assert.Len(t, resultList, 2)
|
|
|
|
for _, r := range resultList {
|
|
assert.Equal(t, StatusOK, r.Status, "file %s should be OK", r.Path)
|
|
}
|
|
}
|
|
|
|
func TestCheckMissingFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testExistsFile: []byte("I exist"),
|
|
"missing.txt": []byte("I don't exist on disk"),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
// Only create one file
|
|
createFilesOnDisk(t, fs, map[string][]byte{
|
|
testExistsFile: []byte("I exist"),
|
|
})
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.Check(context.Background(), results, nil)
|
|
require.NoError(t, err)
|
|
|
|
var okCount, missingCount int
|
|
|
|
for r := range results {
|
|
switch r.Status {
|
|
case StatusOK:
|
|
okCount++
|
|
case StatusMissing:
|
|
missingCount++
|
|
|
|
assert.Equal(t, RelFilePath("missing.txt"), r.Path)
|
|
case StatusSizeMismatch, StatusHashMismatch, StatusExtra, StatusError:
|
|
// Not expected in this test; counted assertions below will fail.
|
|
}
|
|
}
|
|
|
|
assert.Equal(t, 1, okCount)
|
|
assert.Equal(t, 1, missingCount)
|
|
}
|
|
|
|
func TestCheckSizeMismatch(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testFileName: []byte("original content"),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
// Create file with different size
|
|
createFilesOnDisk(t, fs, map[string][]byte{
|
|
testFileName: []byte("short"),
|
|
})
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.Check(context.Background(), results, nil)
|
|
require.NoError(t, err)
|
|
|
|
r := <-results
|
|
assert.Equal(t, StatusSizeMismatch, r.Status)
|
|
assert.Equal(t, RelFilePath(testFileName), r.Path)
|
|
}
|
|
|
|
func TestCheckHashMismatch(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
originalContent := []byte("original content")
|
|
files := map[string][]byte{
|
|
testFileName: originalContent,
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
// Create file with same size but different content
|
|
differentContent := []byte("different contnt") // same length (16 bytes) but different
|
|
require.Len(t, differentContent, len(originalContent), "test requires same length")
|
|
createFilesOnDisk(t, fs, map[string][]byte{
|
|
testFileName: differentContent,
|
|
})
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.Check(context.Background(), results, nil)
|
|
require.NoError(t, err)
|
|
|
|
r := <-results
|
|
assert.Equal(t, StatusHashMismatch, r.Status)
|
|
assert.Equal(t, RelFilePath(testFileName), r.Path)
|
|
}
|
|
|
|
func TestCheckWithProgress(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testFile1: bytes.Repeat([]byte("a"), 100),
|
|
testFile2: bytes.Repeat([]byte("b"), 200),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
progress := make(chan CheckStatus, 10)
|
|
|
|
err = chk.Check(context.Background(), results, progress)
|
|
require.NoError(t, err)
|
|
|
|
// results is fully buffered and closed; no draining needed
|
|
|
|
// Check progress was sent
|
|
var progressUpdates []CheckStatus
|
|
for p := range progress {
|
|
progressUpdates = append(progressUpdates, p)
|
|
}
|
|
|
|
assert.NotEmpty(t, progressUpdates)
|
|
// Final progress should show all files checked
|
|
final := progressUpdates[len(progressUpdates)-1]
|
|
assert.Equal(t, FileCount(2), final.TotalFiles)
|
|
assert.Equal(t, FileCount(2), final.CheckedFiles)
|
|
assert.Equal(t, FileSize(300), final.TotalBytes)
|
|
assert.Equal(t, FileSize(300), final.CheckedBytes)
|
|
assert.Equal(t, FileCount(0), final.Failures)
|
|
}
|
|
|
|
func TestCheckContextCancellation(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
// Create many files to ensure we have time to cancel
|
|
files := make(map[string][]byte)
|
|
for i := range 100 {
|
|
files[string(rune('a'+i%26))+".txt"] = bytes.Repeat([]byte("x"), 1000)
|
|
}
|
|
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel() // Cancel immediately
|
|
|
|
results := make(chan Result, 200)
|
|
err = chk.Check(ctx, results, nil)
|
|
assert.ErrorIs(t, err, context.Canceled)
|
|
}
|
|
|
|
func TestFindExtraFiles(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
// Manifest only contains file1
|
|
manifestFiles := map[string][]byte{
|
|
testFile1: []byte("in manifest"),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, manifestFiles)
|
|
|
|
// Disk has file1 and file2
|
|
createFilesOnDisk(t, fs, map[string][]byte{
|
|
testFile1: []byte("in manifest"),
|
|
testFile2: []byte("extra file"),
|
|
})
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.FindExtraFiles(context.Background(), results)
|
|
require.NoError(t, err)
|
|
|
|
var extras []Result
|
|
for r := range results {
|
|
extras = append(extras, r)
|
|
}
|
|
|
|
assert.Len(t, extras, 1)
|
|
assert.Equal(t, RelFilePath(testFile2), extras[0].Path)
|
|
assert.Equal(t, StatusExtra, extras[0].Status)
|
|
assert.Equal(t, "not in manifest", extras[0].Message)
|
|
}
|
|
|
|
func TestFindExtraFilesSkipsManifestAndDotfiles(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
manifestFiles := map[string][]byte{
|
|
testFile1: []byte("in manifest"),
|
|
}
|
|
createTestManifest(t, fs, "/data/.index.mf", manifestFiles)
|
|
createFilesOnDisk(t, fs, map[string][]byte{
|
|
testFile1: []byte("in manifest"),
|
|
})
|
|
// Create dotfile and manifest that should be skipped
|
|
require.NoError(t, afero.WriteFile(fs, "/data/.hidden", []byte("hidden"), 0o644))
|
|
require.NoError(t, afero.WriteFile(fs, "/data/.config/settings", []byte("cfg"), 0o644))
|
|
// Create a real extra file
|
|
require.NoError(t, fs.MkdirAll(testDataDir, 0o755))
|
|
require.NoError(t, afero.WriteFile(fs, "/data/extra.txt", []byte("extra"), 0o644))
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: "/data/.index.mf",
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.FindExtraFiles(context.Background(), results)
|
|
require.NoError(t, err)
|
|
|
|
var extras []Result
|
|
for r := range results {
|
|
extras = append(extras, r)
|
|
}
|
|
|
|
// Should only report extra.txt, not .hidden, .config/settings, or .index.mf
|
|
for _, e := range extras {
|
|
t.Logf("extra: %s", e.Path)
|
|
}
|
|
|
|
assert.Len(t, extras, 1)
|
|
|
|
if len(extras) > 0 {
|
|
assert.Equal(t, RelFilePath("extra.txt"), extras[0].Path)
|
|
}
|
|
}
|
|
|
|
func TestFindExtraFilesContextCancellation(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{testFileName: []byte("data")}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel() // Cancel immediately
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.FindExtraFiles(ctx, results)
|
|
assert.ErrorIs(t, err, context.Canceled)
|
|
}
|
|
|
|
func TestCheckNilChannels(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{testFileName: []byte("data")}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Should not panic with nil channels
|
|
err = chk.Check(context.Background(), nil, nil)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestFindExtraFilesNilChannel(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{testFileName: []byte("data")}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Should not panic with nil channel
|
|
err = chk.FindExtraFiles(context.Background(), nil)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestCheckSubdirectories(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
"dir1/file1.txt": []byte("content1"),
|
|
"dir1/dir2/file2.txt": []byte("content2"),
|
|
"dir1/dir2/dir3/deep.txt": []byte("deep content"),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
|
|
// Create files with full directory structure
|
|
for path, content := range files {
|
|
fullPath := "/data/" + path
|
|
|
|
require.NoError(t, fs.MkdirAll("/data/dir1/dir2/dir3", 0o755))
|
|
require.NoError(t, afero.WriteFile(fs, fullPath, content, 0o644))
|
|
}
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.Check(context.Background(), results, nil)
|
|
require.NoError(t, err)
|
|
|
|
var okCount int
|
|
|
|
for r := range results {
|
|
assert.Equal(t, StatusOK, r.Status, "file %s should be OK", r.Path)
|
|
|
|
okCount++
|
|
}
|
|
|
|
assert.Equal(t, 3, okCount)
|
|
}
|
|
|
|
func TestCheckMissingFileDetectedWithoutFallback(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Regression test: errors.Is(err, errors.New("...")) never matches because
|
|
// errors.New creates a new value each time. The fix uses os.ErrNotExist instead.
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testExistsFile: []byte("here"),
|
|
"missing.txt": []byte("not on disk"),
|
|
}
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
// Only create one file on disk
|
|
createFilesOnDisk(t, fs, map[string][]byte{
|
|
testExistsFile: []byte("here"),
|
|
})
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.Check(context.Background(), results, nil)
|
|
require.NoError(t, err)
|
|
|
|
statusCounts := map[Status]int{}
|
|
for r := range results {
|
|
statusCounts[r.Status]++
|
|
if r.Status == StatusMissing {
|
|
assert.Equal(t, RelFilePath("missing.txt"), r.Path)
|
|
}
|
|
}
|
|
|
|
assert.Equal(t, 1, statusCounts[StatusOK], "one file should be OK")
|
|
assert.Equal(t, 1, statusCounts[StatusMissing], "one file should be MISSING")
|
|
assert.Equal(t, 0, statusCounts[StatusError], "no files should be ERROR")
|
|
}
|
|
|
|
func TestFindExtraFilesSkipsDotfiles(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Regression test for #16: FindExtraFiles should not report dotfiles
|
|
// or the manifest file itself as extra files.
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testFile1: []byte("in manifest"),
|
|
}
|
|
createTestManifest(t, fs, "/data/.index.mf", files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
// Add dotfiles and manifest file on disk
|
|
require.NoError(t, afero.WriteFile(fs, "/data/.hidden", []byte("dotfile"), 0o644))
|
|
require.NoError(t, fs.MkdirAll("/data/.git", 0o755))
|
|
require.NoError(t,
|
|
afero.WriteFile(fs, "/data/.git/config", []byte("git config"), 0o644))
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: "/data/.index.mf",
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.FindExtraFiles(context.Background(), results)
|
|
require.NoError(t, err)
|
|
|
|
var extras []Result
|
|
for r := range results {
|
|
extras = append(extras, r)
|
|
}
|
|
|
|
// Should report NO extra files — dotfiles and manifest should be skipped
|
|
assert.Empty(t, extras,
|
|
"FindExtraFiles should not report dotfiles or manifest file as extra; got: %v",
|
|
extras)
|
|
}
|
|
|
|
func TestFindExtraFilesSkipsManifestFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// The manifest file itself should never be reported as extra
|
|
fs := afero.NewMemMapFs()
|
|
files := map[string][]byte{
|
|
testFile1: []byte("content"),
|
|
}
|
|
createTestManifest(t, fs, "/data/index.mf", files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: "/data/index.mf",
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.FindExtraFiles(context.Background(), results)
|
|
require.NoError(t, err)
|
|
|
|
var extras []Result
|
|
for r := range results {
|
|
extras = append(extras, r)
|
|
}
|
|
|
|
assert.Empty(t, extras,
|
|
"manifest file should not be reported as extra; got: %v", extras)
|
|
}
|
|
|
|
func TestCheckEmptyManifest(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewMemMapFs()
|
|
// Create manifest with no files
|
|
createTestManifest(t, fs, testManifestPath, map[string][]byte{})
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, FileCount(0), chk.FileCount())
|
|
assert.Equal(t, FileSize(0), chk.TotalBytes())
|
|
|
|
results := make(chan Result, 10)
|
|
err = chk.Check(context.Background(), results, nil)
|
|
require.NoError(t, err)
|
|
|
|
var count int
|
|
for range results {
|
|
count++
|
|
}
|
|
|
|
assert.Equal(t, 0, count)
|
|
}
|
|
|
|
func TestCheckProgressRateLimited(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Create many small files - progress should be rate-limited, not one per file.
|
|
// With rate-limiting to once per second, we should get far fewer progress
|
|
// updates than files (plus one final update).
|
|
fs := afero.NewMemMapFs()
|
|
files := make(map[string][]byte, 100)
|
|
|
|
for i := range 100 {
|
|
name := fmt.Sprintf("file%03d.txt", i)
|
|
files[name] = []byte("content")
|
|
}
|
|
|
|
createTestManifest(t, fs, testManifestPath, files)
|
|
createFilesOnDisk(t, fs, files)
|
|
|
|
chk, err := NewChecker(&CheckerOptions{
|
|
ManifestPath: testManifestPath,
|
|
BasePath: testDataDir,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
results := make(chan Result, 200)
|
|
progress := make(chan CheckStatus, 200)
|
|
err = chk.Check(context.Background(), results, progress)
|
|
require.NoError(t, err)
|
|
|
|
// results is fully buffered and closed; no draining needed
|
|
|
|
// Count progress updates
|
|
var progressCount int
|
|
for range progress {
|
|
progressCount++
|
|
}
|
|
|
|
// Should be far fewer than 100 (rate-limited to once per second)
|
|
// At minimum we get the final update
|
|
assert.GreaterOrEqual(t, progressCount, 1,
|
|
"should get at least the final progress update")
|
|
assert.Less(t, progressCount, 100,
|
|
"progress should be rate-limited, not one per file")
|
|
}
|