package pipeline import ( "context" "path/filepath" "testing" ) // TestOperatorSessionsCloseReopenAndTouch proves the closed-state contract: a // close records closed_at and the session is still listed as history, an explicit // reopen clears it, a prompt (touch) clears it, re-recording clears it, and the // session, its history and its created_at are never deleted or rewritten. func TestOperatorSessionsCloseReopenAndTouch(t *testing.T) { ctx := context.Background() store, err := Open(filepath.Join(t.TempDir(), "close.db")) if err != nil { t.Fatal(err) } defer store.Close() if err := store.RecordOperatorSession(ctx, "ses_a", "/work/a", "A", "operator"); err != nil { t.Fatal(err) } before, err := store.OperatorSessions(ctx) if err != nil { t.Fatal(err) } if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil { t.Fatal(err) } closed, err := store.OperatorSessions(ctx) if err != nil { t.Fatal(err) } if len(closed) != 1 || closed[0].ClosedAt <= 0 { t.Fatalf("close did not record closed_at: %+v", closed) } if closed[0].ID != before[0].ID || closed[0].Directory != before[0].Directory || closed[0].Title != before[0].Title || closed[0].Tag != before[0].Tag || closed[0].CreatedAt != before[0].CreatedAt { t.Fatalf("close changed the session beyond closed_at:\nbefore %+v\nafter %+v", before[0], closed[0]) } one, found, err := store.OperatorSession(ctx, "ses_a") if err != nil || !found || one.ClosedAt <= 0 { t.Fatalf("OperatorSession = %+v found=%v err=%v", one, found, err) } if _, found, err := store.OperatorSession(ctx, "ses_run"); err != nil || found { t.Fatalf("a non-operator session was reported found=%v err=%v", found, err) } if err := store.ReopenOperatorSession(ctx, "ses_a"); err != nil { t.Fatal(err) } if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt != 0 { t.Fatalf("explicit reopen did not clear closed_at: %+v %v", rows, err) } // Prompting (touch) reopens too. if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil { t.Fatal(err) } if err := store.TouchOperatorSession(ctx, "ses_a"); err != nil { t.Fatal(err) } if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt != 0 { t.Fatalf("touch did not clear closed_at: %+v %v", rows, err) } // Re-recording (create/adopt) reopens too. if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil { t.Fatal(err) } if err := store.RecordOperatorSession(ctx, "ses_a", "/work/a", "A", "operator"); err != nil { t.Fatal(err) } if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt != 0 { t.Fatalf("re-record did not clear closed_at: %+v %v", rows, err) } // Closing a session id that is not an operator session writes nothing. if err := store.CloseOperatorSession(ctx, "ses_run"); err != nil { t.Fatalf("closing a non-operator session errored: %v", err) } } // TestOperatorSessionsMigrationAddsClosedAt proves an existing database created // before the closed state opens cleanly: the column is added with a default, so // every existing session stays open and Close/Reopen work afterwards. func TestOperatorSessionsMigrationAddsClosedAt(t *testing.T) { ctx := context.Background() path := filepath.Join(t.TempDir(), "migrate.db") store, err := Open(path) if err != nil { t.Fatal(err) } if err := store.RecordOperatorSession(ctx, "ses_old", "/work/old", "Old", "operator"); err != nil { t.Fatal(err) } // Simulate the pre-closed schema by dropping the column, then reopen. if _, err := store.db.ExecContext(ctx, "ALTER TABLE operator_sessions DROP COLUMN closed_at"); err != nil { t.Fatalf("drop closed_at: %v", err) } if err := store.Close(); err != nil { t.Fatal(err) } store, err = Open(path) if err != nil { t.Fatalf("Open after drop: %v", err) } defer store.Close() rows, err := store.OperatorSessions(ctx) if err != nil { t.Fatal(err) } if len(rows) != 1 || rows[0].ID != "ses_old" || rows[0].ClosedAt != 0 { t.Fatalf("migrated rows = %+v, want the old session open", rows) } if err := store.CloseOperatorSession(ctx, "ses_old"); err != nil { t.Fatal(err) } if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt <= 0 { t.Fatalf("close after migration failed: %+v %v", rows, err) } }