gui module: the plan tab's model, with tests

1 files changed, 187 insertions, 0 deletions

diff --git a/gui/internal/model/plan_test.go b/gui/internal/model/plan_test.go
new file mode 100644
index 0000000..c157b1d
--- /dev/null
+++ b/gui/internal/model/plan_test.go
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package model
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"krino/internal/engine"
+	"krino/internal/plan"
+)
+
+// sandboxDir builds a home with one configured directory holding files, and
+// returns the loaded engine and the home. HOME and every XDG_* live inside
+// the test's temporary directory, as the engine's own tests do.
+func sandboxDir(t *testing.T, conf string, files map[string]string) (*engine.Engine, string) {
+	t.Helper()
+	h := t.TempDir()
+	t.Setenv("HOME", h)
+	for _, v := range []string{"XDG_CONFIG_HOME", "XDG_STATE_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME"} {
+		t.Setenv(v, "")
+	}
+	old := time.Now().Add(-2 * time.Hour)
+	for name, body := range files {
+		p := filepath.Join(h, "dl", name)
+		if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		os.Chtimes(p, old, old)
+	}
+	cdir := filepath.Join(h, ".config", "krino")
+	if err := os.MkdirAll(filepath.Join(cdir, "dirs"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	main := filepath.Join(cdir, "krino.conf")
+	os.WriteFile(main, []byte("(include \"dl\")\n"), 0o644)
+	os.WriteFile(filepath.Join(cdir, "dirs", "dl.conf"), []byte(conf), 0o644)
+	e, errs := engine.Load(main)
+	if len(errs) > 0 {
+		t.Fatal(errs)
+	}
+	return e, h
+}
+
+func planTab(t *testing.T, e *engine.Engine) (*PlanTab, *engine.Session) {
+	t.Helper()
+	s, err := e.NewSession(false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { s.Close() })
+	tab, err := Plan(context.Background(), s, e.Dirs[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	return tab, s
+}
+
+// TestPlanRowsAndCounts: the tab shows one row per file with steps, a row
+// for a file krino could not decide about, the rule that matched, and the
+// counts of the plan's summary line.
+func TestPlanRowsAndCounts(t *testing.T) {
+	conf := "(path \"~/dl\")\n(max-read 1K)\n(exclude (name \"^keep-\"))\n" +
+		"(rule \"pdfs\" (when (type pdf)) (move \"Docs\"))\n" +
+		"(rule \"secret\" (when (content \"classified\")) (move \"Secret\"))\n"
+	e, _ := sandboxDir(t, conf, map[string]string{
+		"a.pdf":      "one",
+		"keep-b.pdf": "two",
+		"c.txt":      strings.Repeat("x", 2048), // over max-read: content unknown
+		"plain.txt":  "nothing",
+	})
+	tab, _ := planTab(t, e)
+	if tab.Counts.Scanned != 4 || tab.Counts.Acting != 1 || tab.Counts.Excluded != 1 {
+		t.Errorf("counts = %+v", tab.Counts)
+	}
+	var acting, attention int
+	for _, r := range tab.Rows {
+		if r.Actable {
+			acting++
+			if r.Rel != "a.pdf" || r.Rule != "pdfs" || !r.Selected {
+				t.Errorf("acting row = %+v", r)
+			}
+		}
+		// A file no rule could act on that still raised a warning is shown
+		// and never selectable; a file with steps stays selectable even
+		// when another rule warned about it.
+		if len(r.Steps) == 0 {
+			attention++
+			if r.Rel != "c.txt" || len(r.Warnings) == 0 || r.Selected || r.Actable {
+				t.Errorf("needs-attention row = %+v", r)
+			}
+		}
+	}
+	if acting != 1 || attention != 1 {
+		t.Errorf("rows = %+v", tab.Rows)
+	}
+}
+
+// TestSelectionAndApply: only the selected files are acted on, the rest are
+// logged as declined, and every row carries its outcome afterwards.
+func TestSelectionAndApply(t *testing.T) {
+	conf := "(path \"~/dl\")\n(rule \"all\" (move \"Out\"))\n"
+	e, h := sandboxDir(t, conf, map[string]string{"a.pdf": "one", "b.pdf": "two"})
+	tab, _ := planTab(t, e)
+	if tab.SelectedCount() != 2 {
+		t.Fatalf("rows do not start selected: %+v", tab.Rows)
+	}
+	tab.SelectNone()
+	if tab.SelectedCount() != 0 {
+		t.Fatal("SelectNone left rows selected")
+	}
+	for i, r := range tab.Rows {
+		if r.Rel == "a.pdf" {
+			tab.Toggle(i)
+		}
+	}
+	res, err := tab.Apply(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Applied != 1 || res.Declined != 1 {
+		t.Errorf("result = %+v", res)
+	}
+	if _, err := os.Stat(filepath.Join(h, "dl", "Out", "a.pdf")); err != nil {
+		t.Errorf("the selected file was not moved: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(h, "dl", "b.pdf")); err != nil {
+		t.Errorf("the unselected file was moved: %v", err)
+	}
+	for _, r := range tab.Rows {
+		want := "done"
+		if r.Rel == "b.pdf" {
+			want = "declined"
+		}
+		if r.Outcome != want {
+			t.Errorf("%s: outcome %q, want %q", r.Rel, r.Outcome, want)
+		}
+	}
+}
+
+// TestReplaceWithTrash: "Trash instead" swaps the planned steps for one
+// trash step, as the terminal review's t key does, and applying it trashes
+// the file.
+func TestReplaceWithTrash(t *testing.T) {
+	conf := "(path \"~/dl\")\n(rule \"all\" (move \"Out\"))\n"
+	e, h := sandboxDir(t, conf, map[string]string{"a.pdf": "one"})
+	tab, _ := planTab(t, e)
+	if err := tab.Replace(0, plan.Trash); err != nil {
+		t.Fatal(err)
+	}
+	if tab.Rows[0].Steps[0].Kind != plan.Trash || tab.Rows[0].Rule != "(review)" {
+		t.Fatalf("row = %+v", tab.Rows[0])
+	}
+	if _, err := tab.Apply(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(filepath.Join(h, "dl", "a.pdf")); !os.IsNotExist(err) {
+		t.Errorf("the file was not trashed: %v", err)
+	}
+	if entries, _ := os.ReadDir(filepath.Join(h, ".local", "share", "Trash", "files")); len(entries) != 1 {
+		t.Errorf("the Trash holds %d entries, want 1", len(entries))
+	}
+	if err := tab.Replace(0, plan.Move); err == nil {
+		t.Error("Replace accepted a move")
+	}
+}
+
+// TestPlanLeavesTheDirectoryAlone: planning changes no file, so a window
+// can sit open on a plan.
+func TestPlanLeavesTheDirectoryAlone(t *testing.T) {
+	conf := "(path \"~/dl\")\n(rule \"all\" (move \"Out\"))\n"
+	e, h := sandboxDir(t, conf, map[string]string{"a.pdf": "one"})
+	planTab(t, e)
+	if _, err := os.Stat(filepath.Join(h, "dl", "a.pdf")); err != nil {
+		t.Errorf("planning moved the file: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(h, "dl", "Out")); !os.IsNotExist(err) {
+		t.Errorf("planning created the destination: %v", err)
+	}
+}