sneak
2b692fad7c
check / check (push) Waiting to run
fetch saves the manifest as index.mf at the top of the tree and refuses a manifest that lists a file there. gen given --output, and freshen with its manifest outside the base directory, listed such a file, so they wrote manifests fetch would not take. gen now leaves out index.mf in each directory it is given, or beside each file it is given, the same way it leaves out the file it writes. freshen leaves out index.mf at the top of the base directory. index.mf in a subdirectory is still listed. The README says so for both commands. Model: opus-5-5
704 lines
22 KiB
Go
704 lines
22 KiB
Go
//nolint:testpackage // white-box tests exercise unexported internals
|
|
package cli
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"crypto/sha512"
|
|
"maps"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/multiformats/go-multihash"
|
|
"github.com/spf13/afero"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/proto"
|
|
"sneak.berlin/go/mfer/mfer"
|
|
)
|
|
|
|
// stubFileInfo is a minimal fs.FileInfo for exercising recordEntry
|
|
// without touching a filesystem.
|
|
type stubFileInfo struct {
|
|
size int64
|
|
mtime time.Time
|
|
}
|
|
|
|
func (s stubFileInfo) Name() string { return "stub" }
|
|
func (s stubFileInfo) Size() int64 { return s.size }
|
|
func (s stubFileInfo) Mode() os.FileMode { return 0 }
|
|
func (s stubFileInfo) ModTime() time.Time { return s.mtime }
|
|
func (s stubFileInfo) IsDir() bool { return false }
|
|
func (s stubFileInfo) Sys() any { return nil }
|
|
|
|
// setupFreshenDir writes files, by path and content, into a fresh temp
|
|
// dir and runs gen on it. It returns the temp dir and the path of the
|
|
// manifest gen wrote there.
|
|
func setupFreshenDir(
|
|
t *testing.T, fs afero.Fs, files map[string]string,
|
|
) (string, string) {
|
|
t.Helper()
|
|
|
|
root := t.TempDir()
|
|
manifestPath := filepath.Join(root, defaultManifestName)
|
|
|
|
for path, content := range files {
|
|
require.NoError(t, fs.MkdirAll(filepath.Dir(filepath.Join(root, path)), 0o750))
|
|
writeTestFile(t, fs, filepath.Join(root, path), content)
|
|
}
|
|
|
|
opts := testOpts([]string{testApp, cmdGenerate, "-q", "-o", manifestPath, root}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
return root, manifestPath
|
|
}
|
|
|
|
// runFreshen runs freshen on the manifest at manifestPath for the tree
|
|
// at root and requires it to succeed.
|
|
func runFreshen(t *testing.T, fs afero.Fs, root, manifestPath string) {
|
|
t.Helper()
|
|
|
|
opts := testOpts([]string{
|
|
testApp, cmdFreshen, "-q", testFlagBase, root, manifestPath,
|
|
}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
}
|
|
|
|
// manifestFiles returns the file entries of the manifest at path.
|
|
func manifestFiles(t *testing.T, fs afero.Fs, path string) []*mfer.MFFilePath {
|
|
t.Helper()
|
|
|
|
// Loading a manifest logs to the process-global logger, so serialize
|
|
// with the CLI runs.
|
|
runMu.Lock()
|
|
defer runMu.Unlock()
|
|
|
|
manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
|
|
Path: path,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
return manifest.Files()
|
|
}
|
|
|
|
// manifestCreatedAt returns the createdAt timestamp of the manifest at
|
|
// path, or nil if it has none.
|
|
func manifestCreatedAt(t *testing.T, fs afero.Fs, path string) *mfer.Timestamp {
|
|
t.Helper()
|
|
|
|
runMu.Lock()
|
|
defer runMu.Unlock()
|
|
|
|
manifest, err := mfer.NewManifestFromFile(&mfer.ManifestFromFileOptions{
|
|
Path: path,
|
|
Fs: fs,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
return manifest.CreatedAt()
|
|
}
|
|
|
|
// TestFreshenUnchanged freshens a tree that has not changed since gen
|
|
// made its manifest: the manifest must list the same entries as before.
|
|
func TestFreshenUnchanged(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewOsFs()
|
|
root, manifestPath := setupFreshenDir(t, fs,
|
|
map[string]string{testFileTxt: "content1", testDirFile: "content2"})
|
|
before := manifestFiles(t, fs, manifestPath)
|
|
|
|
runFreshen(t, fs, root, manifestPath)
|
|
|
|
after := manifestFiles(t, fs, manifestPath)
|
|
require.Len(t, after, len(before))
|
|
|
|
for i := range before {
|
|
assert.True(t, proto.Equal(before[i], after[i]),
|
|
"entry for %s changed", before[i].GetPath())
|
|
}
|
|
}
|
|
|
|
// TestFreshenRecordsModeOnlyWhenAsked changes only the modes of a tree
|
|
// after gen made its manifest, which recorded every mode as 0000. freshen
|
|
// --include-permissions must record each file's permission bits, and a
|
|
// later freshen without it must record 0000 again, although no file's
|
|
// content or mtime changed.
|
|
func TestFreshenRecordsModeOnlyWhenAsked(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewOsFs()
|
|
root, manifestPath := setupFreshenDir(t, fs,
|
|
map[string]string{testFileTxt: "a file", testDirFile: "a file in dir"})
|
|
require.NoError(t, fs.Chmod(filepath.Join(root, testFileTxt), 0o640))
|
|
require.NoError(t, fs.Chmod(filepath.Join(root, testDirFile), 0o755))
|
|
|
|
recordedModes := func() map[string]uint32 {
|
|
modes := map[string]uint32{}
|
|
for _, f := range manifestFiles(t, fs, manifestPath) {
|
|
modes[f.GetPath()] = f.GetMode()
|
|
}
|
|
|
|
return modes
|
|
}
|
|
|
|
opts := testOpts([]string{
|
|
testApp, cmdFreshen, "-q", "--" + flagIncludePermissions,
|
|
testFlagBase, root, manifestPath,
|
|
}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
assert.Equal(t, map[string]uint32{testFileTxt: 0o640, testDirFile: 0o755},
|
|
recordedModes())
|
|
|
|
runFreshen(t, fs, root, manifestPath)
|
|
assert.Equal(t, map[string]uint32{testFileTxt: 0, testDirFile: 0},
|
|
recordedModes())
|
|
}
|
|
|
|
// TestFreshenIncludeTimestampsOnUnchangedTree runs freshen
|
|
// --include-timestamps on a tree that has not changed since gen made its
|
|
// manifest, which has no createdAt timestamp. freshen must rewrite the
|
|
// manifest with one. Run again with the flag it must leave the manifest as
|
|
// it is; run without it, it must rewrite the manifest without one.
|
|
func TestFreshenIncludeTimestampsOnUnchangedTree(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewOsFs()
|
|
root, manifestPath := setupFreshenDir(t, fs, map[string]string{testFileTxt: "hello"})
|
|
|
|
freshenWithTimestamps := func() {
|
|
opts := testOpts([]string{
|
|
testApp, cmdFreshen, "-q", "--include-timestamps",
|
|
testFlagBase, root, manifestPath,
|
|
}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
}
|
|
|
|
freshenWithTimestamps()
|
|
assert.NotNil(t, manifestCreatedAt(t, fs, manifestPath))
|
|
|
|
before, err := afero.ReadFile(fs, manifestPath)
|
|
require.NoError(t, err)
|
|
|
|
freshenWithTimestamps()
|
|
|
|
after, err := afero.ReadFile(fs, manifestPath)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, before, after, "manifest that has a createdAt was rewritten")
|
|
|
|
runFreshen(t, fs, root, manifestPath)
|
|
assert.Nil(t, manifestCreatedAt(t, fs, manifestPath))
|
|
}
|
|
|
|
// assertManifestLists asserts that the manifest at manifestPath lists
|
|
// exactly the files in want, each with the size and SHA-256 hash of its
|
|
// content in want and the mtime of the file of that name under root.
|
|
func assertManifestLists(
|
|
t *testing.T, fs afero.Fs, root, manifestPath string, want map[string]string,
|
|
) {
|
|
t.Helper()
|
|
|
|
files := manifestFiles(t, fs, manifestPath)
|
|
listed := make([]string, 0, len(files))
|
|
|
|
for _, f := range files {
|
|
listed = append(listed, f.GetPath())
|
|
|
|
content, ok := want[f.GetPath()]
|
|
if !ok {
|
|
continue // reported by the ElementsMatch below
|
|
}
|
|
|
|
digest := sha256.Sum256([]byte(content))
|
|
hash, err := multihash.Encode(digest[:], multihash.SHA2_256)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, int64(len(content)), f.GetSize(), f.GetPath())
|
|
require.NotEmpty(t, f.GetHashes(), f.GetPath())
|
|
assert.Equal(t, hash, f.GetHashes()[0].GetMultiHash(), f.GetPath())
|
|
|
|
info, err := fs.Stat(filepath.Join(root, f.GetPath()))
|
|
require.NoError(t, err)
|
|
|
|
mtime, ok := entryMtime(f)
|
|
assert.True(t, ok && mtime.Equal(info.ModTime()),
|
|
"%s: manifest has mtime %v, file has %v",
|
|
f.GetPath(), mtime, info.ModTime())
|
|
}
|
|
|
|
assert.ElementsMatch(t, slices.Collect(maps.Keys(want)), listed)
|
|
}
|
|
|
|
// TestFreshenWithChanges makes one change to a tree after gen made its
|
|
// manifest, then freshens the manifest. The rewritten manifest must list
|
|
// exactly the files now in the tree, and check must pass on the tree.
|
|
func TestFreshenWithChanges(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tree := map[string]string{testFileTxt: "content1", testDirFile: "content2"}
|
|
|
|
// Every file a case writes gets this mtime, which differs from the one
|
|
// gen recorded, so an edit that keeps the size is told apart by its
|
|
// mtime whatever the filesystem's clock resolution.
|
|
writtenMtime := time.Unix(1_700_000_000, 0)
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
write map[string]string // files to write, by path and content
|
|
remove string // file to delete, if any
|
|
}{
|
|
{
|
|
name: "modified file",
|
|
write: map[string]string{testDirFile: "modified content2"},
|
|
},
|
|
{
|
|
name: "modified file, same size",
|
|
write: map[string]string{testDirFile: "CONTENT2"},
|
|
},
|
|
{
|
|
name: "new file",
|
|
write: map[string]string{"dir/new.txt": "content3"},
|
|
},
|
|
{
|
|
name: "deleted file",
|
|
remove: testFileTxt,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := afero.NewOsFs()
|
|
root, manifestPath := setupFreshenDir(t, fs, tree)
|
|
|
|
// want is the tree as it is after the change.
|
|
want := maps.Clone(tree)
|
|
|
|
for path, content := range tc.write {
|
|
writeTestFile(t, fs, filepath.Join(root, path), content)
|
|
require.NoError(t, fs.Chtimes(
|
|
filepath.Join(root, path), writtenMtime, writtenMtime))
|
|
want[path] = content
|
|
}
|
|
|
|
if tc.remove != "" {
|
|
require.NoError(t, fs.Remove(filepath.Join(root, tc.remove)))
|
|
delete(want, tc.remove)
|
|
}
|
|
|
|
runFreshen(t, fs, root, manifestPath)
|
|
|
|
assertManifestLists(t, fs, root, manifestPath, want)
|
|
|
|
opts := testOpts([]string{
|
|
testApp, cmdCheck, "-q", testFlagNoExtra, testFlagBase, root, manifestPath,
|
|
}, fs)
|
|
assert.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
})
|
|
}
|
|
}
|
|
|
|
// growingFileFs appends to one file each time it is opened, as a program
|
|
// still writing to the file would between freshen's scan and its hash.
|
|
type growingFileFs struct {
|
|
afero.Fs
|
|
|
|
path string
|
|
}
|
|
|
|
//nolint:ireturn // Open must return afero.File to satisfy afero.Fs.
|
|
func (f growingFileFs) Open(name string) (afero.File, error) {
|
|
if name == f.path {
|
|
file, err := f.OpenFile(name, os.O_APPEND|os.O_WRONLY, 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
_, err = file.WriteString(" world")
|
|
_ = file.Close()
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return f.Fs.Open(name)
|
|
}
|
|
|
|
// TestFreshenFileChangedSinceScan has a new file grow after freshen's scan
|
|
// recorded its size and before freshen hashes it: freshen must fail and
|
|
// leave the manifest as it was.
|
|
func TestFreshenFileChangedSinceScan(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
osFs := afero.NewOsFs()
|
|
root, manifestPath := setupFreshenDir(t, osFs,
|
|
map[string]string{testFileTxt: "content"})
|
|
grown := filepath.Join(root, "log.txt")
|
|
writeTestFile(t, osFs, grown, "hello")
|
|
|
|
before, err := afero.ReadFile(osFs, manifestPath)
|
|
require.NoError(t, err)
|
|
|
|
opts := testOpts([]string{
|
|
testApp, cmdFreshen, "-q", testFlagBase, root, manifestPath,
|
|
}, growingFileFs{Fs: osFs, path: grown})
|
|
assert.Equal(t, 1, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
after, err := afero.ReadFile(osFs, manifestPath)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, before, after, "manifest changed")
|
|
}
|
|
|
|
// TestFreshenLeavesManifestOutOfListing freshens a manifest kept in a
|
|
// subdirectory of the tree it lists: the manifest is not listed, while an
|
|
// ordinary file of the same name at the top of the tree is. The manifest
|
|
// is recognized by file identity, which needs the real filesystem.
|
|
func TestFreshenLeavesManifestOutOfListing(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
root := t.TempDir()
|
|
manifestPath := filepath.Join(root, "sub", "listing.mf")
|
|
|
|
fs := afero.NewOsFs()
|
|
require.NoError(t, fs.MkdirAll(filepath.Join(root, "sub"), 0o750))
|
|
writeTestFile(t, fs, filepath.Join(root, testFileTxt), "hello")
|
|
writeTestFile(t, fs, filepath.Join(root, "listing.mf"), "an ordinary file")
|
|
|
|
opts := testOpts([]string{testApp, cmdGenerate, "-q", "-o", manifestPath, root}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
// A new file gives freshen something to write.
|
|
writeTestFile(t, fs, filepath.Join(root, "added.txt"), "added")
|
|
|
|
opts = testOpts([]string{
|
|
testApp, "freshen", "-q", testFlagBase, root, manifestPath,
|
|
}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
assert.ElementsMatch(t, []string{testFileTxt, "listing.mf", "added.txt"},
|
|
manifestPaths(t, fs, manifestPath))
|
|
}
|
|
|
|
// TestFreshenLeavesLeftoverTempFileOutOfListing freshens a manifest where
|
|
// an interrupted run left its temp file beside it: the leftover is not
|
|
// listed.
|
|
func TestFreshenLeavesLeftoverTempFileOutOfListing(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
root := t.TempDir()
|
|
manifestPath := filepath.Join(root, "index.mf")
|
|
|
|
fs := afero.NewOsFs()
|
|
writeTestFile(t, fs, filepath.Join(root, testFileTxt), "hello")
|
|
|
|
opts := testOpts([]string{testApp, cmdGenerate, "-q", "-o", manifestPath, root}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
writeTestFile(t, fs, manifestTempPath(manifestPath), "part of a manifest")
|
|
// A new file gives freshen something to write.
|
|
writeTestFile(t, fs, filepath.Join(root, "added.txt"), "added")
|
|
|
|
opts = testOpts([]string{
|
|
testApp, "freshen", "-q", testFlagBase, root, manifestPath,
|
|
}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
assert.ElementsMatch(t, []string{testFileTxt, "added.txt"},
|
|
manifestPaths(t, fs, manifestPath))
|
|
}
|
|
|
|
// TestFreshenLeavesTopIndexMFOutOfListing freshens a manifest kept outside
|
|
// the directory --base names, after index.mf and sub/index.mf are added
|
|
// there: index.mf at the top is not listed, since fetch saves the manifest
|
|
// there, while sub/index.mf is listed. The file is recognized by file
|
|
// identity, which needs the real filesystem.
|
|
func TestFreshenLeavesTopIndexMFOutOfListing(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
root := t.TempDir()
|
|
tree := filepath.Join(root, "tree")
|
|
manifestPath := filepath.Join(root, "other.mf")
|
|
|
|
fs := afero.NewOsFs()
|
|
require.NoError(t, fs.MkdirAll(filepath.Join(tree, testSubdir), 0o750))
|
|
writeTestFile(t, fs, filepath.Join(tree, testFileTxt), "hello")
|
|
|
|
opts := testOpts([]string{testApp, cmdGenerate, "-q", "-o", manifestPath, tree}, fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
writeTestFile(t, fs, filepath.Join(tree, defaultManifestName), "an ordinary file")
|
|
writeTestFile(t, fs, filepath.Join(tree, testSubdirManifest), "an ordinary file")
|
|
|
|
runFreshen(t, fs, tree, manifestPath)
|
|
|
|
assert.ElementsMatch(t, []string{testFileTxt, testSubdirManifest},
|
|
manifestPaths(t, fs, manifestPath))
|
|
}
|
|
|
|
// TestFreshenResolvesEntriesAgainstManifestDirectory adds sub/c.txt, then
|
|
// runs freshen from the directory above sub, on the manifest in sub.
|
|
// Without --base, the manifest then lists the files in sub, whether freshen
|
|
// is given the manifest or sub. --base names the directory to list instead,
|
|
// the current one included.
|
|
//
|
|
//nolint:paralleltest // changes the process-global working directory
|
|
func TestFreshenResolvesEntriesAgainstManifestDirectory(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
args []string
|
|
want []string // the paths the manifest lists afterwards
|
|
}{
|
|
{[]string{testSubdir}, []string{"b.txt", "c.txt"}},
|
|
{[]string{testSubdirManifest}, []string{"b.txt", "c.txt"}},
|
|
{
|
|
[]string{testFlagBase, ".", testSubdirManifest},
|
|
[]string{testFileTxt, "sub/b.txt", "sub/c.txt"},
|
|
},
|
|
} {
|
|
t.Run(strings.Join(tc.args, " "), func(t *testing.T) {
|
|
fs := afero.NewOsFs()
|
|
root := setupManifestInSubdir(t)
|
|
writeTestFile(t, fs, filepath.Join(root, testSubdir, "c.txt"), "added")
|
|
|
|
opts := testOpts(slices.Concat(
|
|
[]string{testApp, cmdFreshen, "-q"}, tc.args,
|
|
), fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
assert.ElementsMatch(t, tc.want, manifestPaths(t, fs,
|
|
filepath.Join(root, testSubdirManifest)))
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFreshenDirectoryNamedThroughSymlink adds a file to a tree after gen
|
|
// made its manifest, then freshens it with the tree named through a symlink,
|
|
// given as the argument or as the working directory: the manifest lists the
|
|
// files in the tree, and leaves out a symlink inside it, as freshen does
|
|
// without --follow-symlinks.
|
|
//
|
|
//nolint:paralleltest // changes the process-global working directory
|
|
func TestFreshenDirectoryNamedThroughSymlink(t *testing.T) {
|
|
// Paths are relative to a temp dir holding link, a symlink to the tree.
|
|
for name, tc := range map[string]struct {
|
|
workDir string
|
|
args []string
|
|
}{
|
|
"argument": {".", []string{testLink}},
|
|
"working directory": {testLink, nil},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
fs := afero.NewOsFs()
|
|
tree, manifestPath := setupFreshenDir(t, fs,
|
|
map[string]string{testFileTxt: "in the tree"})
|
|
writeTestFile(t, fs, filepath.Join(tree, "later.txt"), "added later")
|
|
require.NoError(t,
|
|
os.Symlink(testFileTxt, filepath.Join(tree, "alias.txt")))
|
|
|
|
root := t.TempDir()
|
|
require.NoError(t, os.Symlink(tree, filepath.Join(root, testLink)))
|
|
|
|
// t.Chdir sets PWD to the path it is given, as a shell does, and
|
|
// os.Getwd returns PWD when it names the working directory.
|
|
t.Chdir(filepath.Join(root, tc.workDir))
|
|
|
|
opts := testOpts(slices.Concat(
|
|
[]string{testApp, cmdFreshen, "-q"}, tc.args,
|
|
), fs)
|
|
require.Equal(t, 0, runCLI(opts), "stderr: %s", testStderr(t, opts))
|
|
|
|
assertManifestLists(t, fs, tree, manifestPath, map[string]string{
|
|
testFileTxt: "in the tree", "later.txt": "added later",
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFreshenRecordEntryMtimePresence pins the behavior of recordEntry
|
|
// with respect to MFFilePath.Mtime, which is a message pointer with
|
|
// proto3 field presence and may legitimately be absent.
|
|
//
|
|
// An absent mtime must never be read as time.Unix(0, 0): that value
|
|
// never equals a real modification time, so every entry would be
|
|
// classified as changed, re-hashed, and the manifest rewritten
|
|
// unconditionally - the exact inverse of what freshen is for, and
|
|
// silent. An entry with no mtime is therefore "changed" because it
|
|
// cannot be compared, not because it looks like it dates from 1970.
|
|
func TestFreshenRecordEntryMtimePresence(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const relPath = "file1.txt"
|
|
|
|
// The scanned file's mtime is the Unix epoch. If recordEntry ever misreads
|
|
// an absent manifest mtime as the epoch, the "absent" case below would
|
|
// compare equal to this and be classified unchanged, so the test fails.
|
|
mtime := time.Unix(0, 0)
|
|
info := stubFileInfo{size: 8, mtime: mtime}
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
entry *mfer.MFFilePath
|
|
needsHash bool
|
|
changed int64
|
|
unchanged int64
|
|
}{
|
|
{
|
|
name: "matching mtime and size is unchanged",
|
|
entry: &mfer.MFFilePath{
|
|
Path: relPath,
|
|
Size: 8,
|
|
Mtime: &mfer.Timestamp{Seconds: mtime.Unix()},
|
|
},
|
|
needsHash: false,
|
|
changed: 0,
|
|
unchanged: 1,
|
|
},
|
|
{
|
|
name: "absent mtime is changed, not epoch",
|
|
entry: &mfer.MFFilePath{
|
|
Path: relPath,
|
|
Size: 8,
|
|
Mtime: nil,
|
|
},
|
|
needsHash: true,
|
|
changed: 1,
|
|
unchanged: 0,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
s := &freshenScanner{
|
|
existingByPath: map[string]*mfer.MFFilePath{relPath: tc.entry},
|
|
}
|
|
|
|
// recordEntry logs to the process-global logger.
|
|
runMu.Lock()
|
|
s.recordEntry(relPath, info)
|
|
runMu.Unlock()
|
|
|
|
require.Len(t, s.entries, 1)
|
|
assert.Equal(t, tc.needsHash, s.entries[0].needsHash)
|
|
assert.Equal(t, tc.changed, s.changed)
|
|
assert.Equal(t, tc.unchanged, s.unchanged)
|
|
assert.Zero(t, s.added)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFreshenAddExistingRejectsMissingMtime pins that an entry with no
|
|
// mtime is never carried forward into a rebuilt manifest with a
|
|
// fabricated epoch timestamp.
|
|
func TestFreshenAddExistingRejectsMissingMtime(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
hash, err := multihash.Encode(make([]byte, sha256.Size), multihash.SHA2_256)
|
|
require.NoError(t, err)
|
|
|
|
b := mfer.NewBuilder()
|
|
entry := &mfer.MFFilePath{
|
|
Path: "file1.txt",
|
|
Size: 8,
|
|
Mtime: nil,
|
|
Hashes: []*mfer.MFFileChecksum{
|
|
{MultiHash: hash},
|
|
},
|
|
}
|
|
|
|
err = addExistingToBuilder(b, entry)
|
|
require.ErrorIs(t, err, errEntryMissingMtime)
|
|
assert.Contains(t, err.Error(), "file1.txt")
|
|
}
|
|
|
|
// TestFreshenAddExistingRejectsMissingHash pins that an entry with no
|
|
// SHA-256 hash, whether it lists no hash or only a SHA-1 one, is an error
|
|
// rather than a file left out of the rebuilt manifest.
|
|
func TestFreshenAddExistingRejectsMissingHash(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
sha1Hash, err := multihash.Encode(make([]byte, 20), multihash.SHA1)
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
hashes []*mfer.MFFileChecksum
|
|
}{
|
|
{"no hash", nil},
|
|
{"SHA-1 hash only", []*mfer.MFFileChecksum{{MultiHash: sha1Hash}}},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
b := mfer.NewBuilder()
|
|
entry := &mfer.MFFilePath{
|
|
Path: "data.bin",
|
|
Size: 8,
|
|
Mtime: &mfer.Timestamp{Seconds: 1_700_000_000},
|
|
Hashes: tt.hashes,
|
|
}
|
|
|
|
err := addExistingToBuilder(b, entry)
|
|
require.ErrorIs(t, err, errEntryMissingHash)
|
|
assert.Contains(t, err.Error(), "data.bin")
|
|
assert.Zero(t, b.FileCount())
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFreshenAddExistingKeepsSHA256Hash pins that an unchanged entry that
|
|
// lists another hash before its SHA-256 hash is carried over with the
|
|
// SHA-256 hash, the one check and fetch compare with, and nothing else.
|
|
func TestFreshenAddExistingKeepsSHA256Hash(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
sha512Hash, err := multihash.Encode(make([]byte, sha512.Size), multihash.SHA2_512)
|
|
require.NoError(t, err)
|
|
|
|
sha256Hash, err := multihash.Encode(make([]byte, sha256.Size), multihash.SHA2_256)
|
|
require.NoError(t, err)
|
|
|
|
b := mfer.NewBuilder()
|
|
entry := &mfer.MFFilePath{
|
|
Path: "kept.txt",
|
|
Size: 6,
|
|
Mtime: &mfer.Timestamp{Seconds: 1_700_000_000},
|
|
Hashes: []*mfer.MFFileChecksum{
|
|
{MultiHash: sha512Hash},
|
|
{MultiHash: sha256Hash},
|
|
},
|
|
}
|
|
|
|
require.NoError(t, addExistingToBuilder(b, entry))
|
|
|
|
var buf bytes.Buffer
|
|
require.NoError(t, b.Build(context.Background(), &buf))
|
|
|
|
m, err := mfer.NewManifestFromReader(&buf)
|
|
require.NoError(t, err)
|
|
require.Len(t, m.Files(), 1)
|
|
require.Len(t, m.Files()[0].GetHashes(), 1)
|
|
assert.Equal(t, sha256Hash, m.Files()[0].GetHashes()[0].GetMultiHash())
|
|
}
|
|
|
|
// TestEntryMtime pins the presence semantics the callers depend on.
|
|
func TestEntryMtime(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, ok := entryMtime(&mfer.MFFilePath{Mtime: nil})
|
|
assert.False(t, ok)
|
|
assert.True(t, got.IsZero())
|
|
|
|
got, ok = entryMtime(&mfer.MFFilePath{
|
|
Mtime: &mfer.Timestamp{Seconds: 1_700_000_000, Nanos: 500},
|
|
})
|
|
assert.True(t, ok)
|
|
assert.Equal(t, time.Unix(1_700_000_000, 500), got)
|
|
}
|