From 40ecbfae85c4c76a8ed944a91f8c000b4ec55fc5 Mon Sep 17 00:00:00 2001
From: Lukasz Kasprzak <lukas@labunix.xyz>
Date: Wed, 16 Sep 2026 00:59:08 +0200
Subject: undo runs through the same session

---
 internal/engine/session_test.go | 63 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

(limited to 'internal/engine/session_test.go')

diff --git a/internal/engine/session_test.go b/internal/engine/session_test.go
index ece69dd..8fd4593 100644
--- a/internal/engine/session_test.go
+++ b/internal/engine/session_test.go
@@ -47,6 +47,9 @@ func TestSessionKeepsOnlyAppliedDestinationsClaimed(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer s.Close()
+	if err := s.OpenLog(); err != nil {
+		t.Fatal(err)
+	}
 	if s.Run() == "" {
 		t.Error("a real session has no run id")
 	}
@@ -79,6 +82,9 @@ func TestDrySessionWritesNoLog(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer s.Close()
+	if err := s.OpenLog(); err != nil {
+		t.Fatal(err)
+	}
 	if s.Run() != "" {
 		t.Errorf("a dry session took a run id: %q", s.Run())
 	}
@@ -117,3 +123,60 @@ func TestSessionLockIsTheDirectorysOwn(t *testing.T) {
 		l2.Release()
 	}
 }
+
+// TestSessionUndoReversesTheRun: undo goes through the same session as
+// sorting - its locks, its log, its run id (GUI design §1.3).
+func TestSessionUndoReversesTheRun(t *testing.T) {
+	e, run, h, _ := appliedRun(t, map[string]map[string]string{"dl": {"a.pdf": "one"}},
+		map[string]string{"dl": "(path \"~/dl\")\n(rule \"r\" (move \"Out\"))\n"})
+	s, err := e.NewSession(false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer s.Close()
+	locks, err := s.LockDirs(context.Background(), []string{"dl"}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	up, err := s.PlanUndo(run)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.ApplyUndo(context.Background(), up); err != nil {
+		t.Fatal(err)
+	}
+	for _, l := range locks {
+		l.Release()
+	}
+	if _, err := os.Stat(filepath.Join(h, "dl", "a.pdf")); err != nil {
+		t.Errorf("undo did not put the file back: %v", err)
+	}
+}
+
+// TestSessionLockDirsReleasesOnFailure: when one directory's lock cannot be
+// had, the locks already taken are released, so a failed undo leaves none
+// held.
+func TestSessionLockDirsReleasesOnFailure(t *testing.T) {
+	h := sandbox(t)
+	e := twoOverwritingDirs(t, h)
+	s, err := e.NewSession(true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer s.Close()
+	held, err := s.Lock(context.Background(), e.Dirs[1], false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.LockDirs(context.Background(), []string{"a", "b"}, false); err == nil {
+		t.Fatal("LockDirs took a lock another holder had")
+	}
+	held.Release()
+	locks, err := s.LockDirs(context.Background(), []string{"a", "b"}, false)
+	if err != nil {
+		t.Fatalf("the first directory's lock was left held: %v", err)
+	}
+	for _, l := range locks {
+		l.Release()
+	}
+}
-- 
cgit v1.3