438 lines
13 KiB
Go
438 lines
13 KiB
Go
package archive
|
|
|
|
import (
|
|
"bytes"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func mkTransmittal(t *testing.T, fsRoot, folderName string, files ...string) {
|
|
t.Helper()
|
|
dir := filepath.Join(fsRoot, folderName)
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
t.Fatalf("mkdir %s: %v", dir, err)
|
|
}
|
|
for _, f := range files {
|
|
path := filepath.Join(dir, f)
|
|
if err := os.WriteFile(path, []byte("x"), 0o644); err != nil {
|
|
t.Fatalf("write %s: %v", path, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompareRevisions_DraftOrdering(t *testing.T) {
|
|
cases := []struct {
|
|
a, b string
|
|
want int // sign only
|
|
}{
|
|
{"~A", "A", -1},
|
|
{"~A", "~B", -1},
|
|
{"A", "B", -1},
|
|
{"~A", "~A", 0},
|
|
{"A", "~A", 1},
|
|
}
|
|
for _, c := range cases {
|
|
got := compareRevisions(c.a, c.b)
|
|
var sign int
|
|
if got < 0 {
|
|
sign = -1
|
|
} else if got > 0 {
|
|
sign = 1
|
|
}
|
|
if sign != c.want {
|
|
t.Errorf("compareRevisions(%q, %q) sign = %d, want %d", c.a, c.b, sign, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIndexAndResolve_DraftOnly(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_T1 (IFR) - Title",
|
|
"123_~A (IFR) - Title.pdf",
|
|
)
|
|
|
|
idx, err := BuildIndex(root)
|
|
if err != nil {
|
|
t.Fatalf("BuildIndex: %v", err)
|
|
}
|
|
|
|
pe, ok := idx.ByProject["ProjectA"]
|
|
if !ok {
|
|
t.Fatalf("ProjectA bucket not indexed; ByProject = %v", idx.ByProject)
|
|
}
|
|
te, ok := pe.ByTracking["123"]
|
|
if !ok {
|
|
t.Fatalf("tracking 123 not indexed in ProjectA")
|
|
}
|
|
if te.HighestBaseRev != "~A" {
|
|
t.Errorf("HighestBaseRev = %q, want ~A", te.HighestBaseRev)
|
|
}
|
|
|
|
if _, ok := Resolve(idx, "ProjectA", "123.html"); !ok {
|
|
t.Errorf("Resolve(ProjectA, 123.html) failed")
|
|
}
|
|
if _, ok := Resolve(idx, "ProjectA", "123_~A.html"); !ok {
|
|
t.Errorf("Resolve(ProjectA, 123_~A.html) failed")
|
|
}
|
|
|
|
// Same tracking number queried under a different project must NOT resolve.
|
|
if _, ok := Resolve(idx, "ProjectB", "123.html"); ok {
|
|
t.Errorf("Resolve(ProjectB, 123.html) should fail — 123 belongs to ProjectA")
|
|
}
|
|
// Empty project — /.archive/ at the very root — never resolves.
|
|
if _, ok := Resolve(idx, "", "123.html"); ok {
|
|
t.Errorf("Resolve(\"\", 123.html) should fail — empty project must 404")
|
|
}
|
|
}
|
|
|
|
func TestIndexAndResolve_DraftWithModifier(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_T1 (IFR) - Title",
|
|
"123_~A (IFR) - Title.pdf",
|
|
)
|
|
mkTransmittal(t, root, "ProjectA/2025-02-01_T2 (RTN) - Comments",
|
|
"123_~A+C1 (RTN) - Comments.pdf",
|
|
)
|
|
|
|
idx, _ := BuildIndex(root)
|
|
if _, ok := Resolve(idx, "ProjectA", "123_~A+C1.html"); !ok {
|
|
t.Errorf("Resolve(ProjectA, 123_~A+C1.html) failed")
|
|
}
|
|
}
|
|
|
|
// "First chronologically found version of the latest rev": when the same rev
|
|
// appears in two transmittals within ONE project, the earlier date's copy
|
|
// wins. (Cross-project duplicates are handled separately — see
|
|
// TestCrossProject_NoCollision.)
|
|
func TestRecordFile_FirstChronologicalWins(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-03-01_Late (IFR) - Title",
|
|
"123_A (IFR) - Title.pdf",
|
|
)
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_Early (IFR) - Title",
|
|
"123_A (IFR) - Title.pdf",
|
|
)
|
|
|
|
idx, _ := BuildIndex(root)
|
|
target, ok := Resolve(idx, "ProjectA", "123_A.html")
|
|
if !ok {
|
|
t.Fatalf("Resolve(ProjectA, 123_A.html) failed")
|
|
}
|
|
if !contains(target, "2025-01-01_Early") {
|
|
t.Errorf("got %q, want path under 2025-01-01_Early/", target)
|
|
}
|
|
}
|
|
|
|
// Same tracking number issued under two different projects must NOT collide:
|
|
// each project's bucket carries its own copy and resolves independently.
|
|
func TestCrossProject_NoCollision(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_T1 (IFR) - Title",
|
|
"123_A (IFR) - Title.pdf",
|
|
)
|
|
mkTransmittal(t, root, "ProjectB/2025-06-01_T9 (IFR) - Different Title",
|
|
"123_A (IFR) - Different Title.pdf",
|
|
)
|
|
|
|
idx, _ := BuildIndex(root)
|
|
|
|
a, okA := Resolve(idx, "ProjectA", "123_A.html")
|
|
if !okA {
|
|
t.Fatalf("Resolve(ProjectA, 123_A.html) failed")
|
|
}
|
|
if !contains(a, "ProjectA/") {
|
|
t.Errorf("ProjectA target = %q, want path under ProjectA/", a)
|
|
}
|
|
|
|
b, okB := Resolve(idx, "ProjectB", "123_A.html")
|
|
if !okB {
|
|
t.Fatalf("Resolve(ProjectB, 123_A.html) failed")
|
|
}
|
|
if !contains(b, "ProjectB/") {
|
|
t.Errorf("ProjectB target = %q, want path under ProjectB/", b)
|
|
}
|
|
|
|
if a == b {
|
|
t.Errorf("ProjectA and ProjectB targets must differ; got %q == %q", a, b)
|
|
}
|
|
|
|
// Each project's listing surfaces only its own tracking numbers.
|
|
aNames := entryNames(idx.AllEntries("ProjectA"))
|
|
bNames := entryNames(idx.AllEntries("ProjectB"))
|
|
for _, n := range aNames {
|
|
for _, m := range bNames {
|
|
if n == m && n == "123_A.html" {
|
|
// Same URLName is expected; targets just differ.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// AllEntries: every (tracking) gets <tracking>.html (highest) AND a
|
|
// <tracking>_<rev>.html for every base revision present, scoped to project.
|
|
func TestAllEntries_PerRevisionSurfaced(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_T1 (IFR) - Title",
|
|
"123_~A (IFR) - Title.pdf",
|
|
)
|
|
mkTransmittal(t, root, "ProjectA/2025-03-01_T3 (IFC) - Title",
|
|
"123_A (IFC) - Title.pdf",
|
|
"456_0 (IFR) - Other.pdf",
|
|
)
|
|
|
|
idx, _ := BuildIndex(root)
|
|
entries := idx.AllEntries("ProjectA")
|
|
|
|
got := make(map[string]string, len(entries))
|
|
for _, e := range entries {
|
|
got[e.URLName] = e.TargetPath
|
|
}
|
|
|
|
// Highest-rev shortcut + each per-rev redirect should be present.
|
|
wantNames := []string{
|
|
"123.html", // highest of 123 → A
|
|
"123_A.html", // explicit A
|
|
"123_~A.html", // explicit draft
|
|
"456.html", // highest of 456 → 0
|
|
"456_0.html", // explicit 0
|
|
}
|
|
for _, n := range wantNames {
|
|
if _, ok := got[n]; !ok {
|
|
t.Errorf("missing entry %q; got %v", n, sortedKeys(got))
|
|
}
|
|
}
|
|
|
|
// 123.html should resolve to the same path as 123_A.html (both point to
|
|
// the highest-rev's first-chronological copy).
|
|
if got["123.html"] != got["123_A.html"] {
|
|
t.Errorf("123.html (%q) != 123_A.html (%q); should both resolve to highest",
|
|
got["123.html"], got["123_A.html"])
|
|
}
|
|
|
|
// Sort: <tracking>.html sorts before <tracking>_*.html (because '.'<'_').
|
|
for i := 1; i < len(entries); i++ {
|
|
if entries[i-1].URLName > entries[i].URLName {
|
|
t.Errorf("AllEntries not sorted: %q before %q", entries[i-1].URLName, entries[i].URLName)
|
|
}
|
|
}
|
|
|
|
// Empty project key returns nil — root .archive doesn't exist.
|
|
if got := idx.AllEntries(""); got != nil {
|
|
t.Errorf("AllEntries(\"\") = %v, want nil", got)
|
|
}
|
|
if got := idx.AllEntries("NoSuchProject"); got != nil {
|
|
t.Errorf("AllEntries(NoSuchProject) = %v, want nil", got)
|
|
}
|
|
}
|
|
|
|
// Modifier-only files (no base) don't get a <tracking>.html or
|
|
// <tracking>_<rev>.html entry — the redirect would have nowhere to go since
|
|
// re.BasePath is empty. They remain reachable via <tracking>_<rev>+<mod>.html
|
|
// through the resolver but are not surfaced in the listing.
|
|
func TestAllEntries_ModifierOnlyNoBaseSkipped(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-02-01_T2 (RTN) - Comments",
|
|
"123_~A+C1 (RTN) - Comments.pdf",
|
|
)
|
|
|
|
idx, _ := BuildIndex(root)
|
|
for _, e := range idx.AllEntries("ProjectA") {
|
|
if e.URLName == "123.html" || e.URLName == "123_~A.html" {
|
|
t.Errorf("unexpected entry %q (no base file exists)", e.URLName)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Within-project collision: two different files claim to be the same
|
|
// (project, tracking, rev). Chronological winner still wins, but a WARN log
|
|
// is emitted with both paths so the authoring mistake is diagnosable.
|
|
//
|
|
// (Cross-project duplicates are NOT collisions — they live in separate
|
|
// buckets. See TestCrossProject_NoCollision.)
|
|
func TestRecordFile_WithinProjectCollisionLogged(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-03-01_Late (IFR) - Title",
|
|
"123_A (IFR) - Title.pdf",
|
|
)
|
|
// Different transmittal folder, same tracking+rev — e.g. operator
|
|
// re-issued under a different cover sheet by mistake.
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_Early (IFR) - Title",
|
|
"123_A (IFR) - Title.pdf",
|
|
)
|
|
|
|
// Capture slog output during BuildIndex.
|
|
var buf bytes.Buffer
|
|
prev := slog.Default()
|
|
slog.SetDefault(slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{Level: slog.LevelDebug})))
|
|
defer slog.SetDefault(prev)
|
|
|
|
idx, err := BuildIndex(root)
|
|
if err != nil {
|
|
t.Fatalf("BuildIndex: %v", err)
|
|
}
|
|
|
|
logged := buf.String()
|
|
if !strings.Contains(logged, "within-project revision collision") {
|
|
t.Errorf("expected collision WARN; got log:\n%s", logged)
|
|
}
|
|
if !strings.Contains(logged, "project=ProjectA") {
|
|
t.Errorf("expected project field in log; got:\n%s", logged)
|
|
}
|
|
if !strings.Contains(logged, "tracking=123") {
|
|
t.Errorf("expected tracking field in log; got:\n%s", logged)
|
|
}
|
|
|
|
// Chronological winner still wins.
|
|
target, ok := Resolve(idx, "ProjectA", "123_A.html")
|
|
if !ok {
|
|
t.Fatalf("Resolve failed")
|
|
}
|
|
if !contains(target, "2025-01-01_Early") {
|
|
t.Errorf("got %q, want path under 2025-01-01_Early/ (chronological winner)", target)
|
|
}
|
|
}
|
|
|
|
// Re-indexing the same transmittal folder (e.g. via the watcher) must NOT
|
|
// trip the collision detector — same path is a no-op, not a conflict.
|
|
func TestRecordFile_ReindexSamePathNoCollisionLog(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_T1 (IFR) - Title",
|
|
"123_A (IFR) - Title.pdf",
|
|
)
|
|
|
|
var buf bytes.Buffer
|
|
prev := slog.Default()
|
|
slog.SetDefault(slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{Level: slog.LevelDebug})))
|
|
defer slog.SetDefault(prev)
|
|
|
|
idx, err := BuildIndex(root)
|
|
if err != nil {
|
|
t.Fatalf("BuildIndex: %v", err)
|
|
}
|
|
// Simulate the watcher firing again on the same transmittal folder.
|
|
transmittalAbs := filepath.Join(root, "ProjectA", "2025-01-01_T1 (IFR) - Title")
|
|
if err := idx.UpdateFromDir(root, transmittalAbs); err != nil {
|
|
t.Fatalf("UpdateFromDir: %v", err)
|
|
}
|
|
|
|
if strings.Contains(buf.String(), "within-project revision collision") {
|
|
t.Errorf("re-index should not log collision; got:\n%s", buf.String())
|
|
}
|
|
}
|
|
|
|
// Rebuild atomically replaces the index contents with a fresh walk of fsRoot.
|
|
// Files added after the initial build but before Rebuild are picked up;
|
|
// files removed are dropped. Counts and duration come back for the caller.
|
|
func TestRebuild_PicksUpAddsAndDrops(t *testing.T) {
|
|
root := t.TempDir()
|
|
mkTransmittal(t, root, "ProjectA/2025-01-01_T1 (IFR) - Title",
|
|
"100_A (IFR) - Title.pdf",
|
|
)
|
|
|
|
idx, err := BuildIndex(root)
|
|
if err != nil {
|
|
t.Fatalf("BuildIndex: %v", err)
|
|
}
|
|
if _, ok := Resolve(idx, "ProjectA", "100.html"); !ok {
|
|
t.Fatalf("pre-rebuild: 100 should resolve")
|
|
}
|
|
if _, ok := Resolve(idx, "ProjectA", "200.html"); ok {
|
|
t.Fatalf("pre-rebuild: 200 should NOT resolve yet")
|
|
}
|
|
|
|
// Add a second tracking number into a NEW transmittal folder (the
|
|
// inotify watcher would miss this on SMB; Rebuild must catch it).
|
|
mkTransmittal(t, root, "ProjectA/2025-02-01_T2 (IFR) - Other",
|
|
"200_A (IFR) - Other.pdf",
|
|
)
|
|
|
|
dur, projects, tracking, err := idx.Rebuild(root)
|
|
if err != nil {
|
|
t.Fatalf("Rebuild: %v", err)
|
|
}
|
|
if dur <= 0 {
|
|
t.Errorf("Rebuild duration = %v, want > 0", dur)
|
|
}
|
|
if projects != 1 {
|
|
t.Errorf("projects = %d, want 1", projects)
|
|
}
|
|
if tracking != 2 {
|
|
t.Errorf("tracking = %d, want 2 (100, 200)", tracking)
|
|
}
|
|
|
|
if _, ok := Resolve(idx, "ProjectA", "100.html"); !ok {
|
|
t.Errorf("post-rebuild: 100 lost")
|
|
}
|
|
if _, ok := Resolve(idx, "ProjectA", "200.html"); !ok {
|
|
t.Errorf("post-rebuild: 200 not picked up")
|
|
}
|
|
|
|
// Remove the original transmittal entirely; Rebuild should drop it.
|
|
if err := os.RemoveAll(filepath.Join(root, "ProjectA/2025-01-01_T1 (IFR) - Title")); err != nil {
|
|
t.Fatalf("RemoveAll: %v", err)
|
|
}
|
|
if _, _, _, err := idx.Rebuild(root); err != nil {
|
|
t.Fatalf("Rebuild: %v", err)
|
|
}
|
|
if _, ok := Resolve(idx, "ProjectA", "100.html"); ok {
|
|
t.Errorf("post-second-rebuild: 100 should be gone")
|
|
}
|
|
if _, ok := Resolve(idx, "ProjectA", "200.html"); !ok {
|
|
t.Errorf("post-second-rebuild: 200 lost")
|
|
}
|
|
}
|
|
|
|
// projectOf is the canonical place to derive the project key. Validate the
|
|
// edge cases so the contract doesn't drift silently.
|
|
func TestProjectOf(t *testing.T) {
|
|
cases := []struct {
|
|
path string
|
|
want string
|
|
}{
|
|
{"ProjectA/2025-01-01_T1/100_A.pdf", "ProjectA"},
|
|
{"ProjectA/sub/deep/file.pdf", "ProjectA"},
|
|
// Files at the root with no slash have no project.
|
|
{"top-level-loose-file.pdf", ""},
|
|
{"", ""},
|
|
// Defensive: leading slash should never reach this helper, but if it
|
|
// did, we'd return "" rather than picking up an empty leading segment.
|
|
{"/ProjectA/file", ""},
|
|
}
|
|
for _, c := range cases {
|
|
got := projectOf(c.path)
|
|
if got != c.want {
|
|
t.Errorf("projectOf(%q) = %q, want %q", c.path, got, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func contains(s, sub string) bool {
|
|
for i := 0; i+len(sub) <= len(s); i++ {
|
|
if s[i:i+len(sub)] == sub {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func sortedKeys(m map[string]string) []string {
|
|
out := make([]string, 0, len(m))
|
|
for k := range m {
|
|
out = append(out, k)
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|
|
|
|
func entryNames(entries []Entry) []string {
|
|
out := make([]string, 0, len(entries))
|
|
for _, e := range entries {
|
|
out = append(out, e.URLName)
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|