126 lines
5.4 KiB
Python
126 lines
5.4 KiB
Python
import contextlib
|
|
import gzip
|
|
import io
|
|
from unittest import mock
|
|
import os
|
|
import pathlib
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import unittest
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
|
from text_files.doubles import compress
|
|
from failure import Failure
|
|
from compress_archives import main
|
|
|
|
DAY = 24 * 60 * 60
|
|
# A month ahead, so a file's ctime, which is when the test wrote it, lies over 30 days before NOW.
|
|
NOW = time.time() + 31 * DAY
|
|
OLD = 30 * DAY + 60
|
|
NEW = 30 * DAY - 60
|
|
|
|
|
|
class Main(unittest.TestCase):
|
|
"""A home whose archive and review folders each hold files that last changed a minute over 30 days ago, and one that changed a minute under."""
|
|
|
|
def setUp(self):
|
|
self.home = pathlib.Path(self.enterContext(tempfile.TemporaryDirectory()))
|
|
self.archive = self.home / ".claude" / "loop-claude-transcripts" / "proj" / "c1"
|
|
self.reviews = self.home / ".local" / "state" / "larv-review" / "code" / "proj-item-1"
|
|
for folder in (self.archive / "session" / "s" / "subagents", self.reviews / "probe"):
|
|
folder.mkdir(parents=True)
|
|
self.write(self.archive / "a.jsonl", OLD)
|
|
self.write(self.archive / "a.outcomes.md", OLD)
|
|
self.write(self.archive / "session" / "s" / "subagents" / "agent-a.jsonl", OLD)
|
|
self.write(self.archive / "session" / "s" / "subagents" / "agent-a.meta.json", OLD)
|
|
self.write(self.archive / "b.jsonl", NEW)
|
|
self.write(self.reviews / "stability-round-1.md", OLD)
|
|
self.write(self.reviews / "probe" / "out.js", OLD)
|
|
self.write(self.reviews / "branch-1.diff", NEW)
|
|
|
|
def write(self, path, seconds_ago):
|
|
path.write_bytes(f"{path.name}\n".encode())
|
|
os.utime(path, (NOW - seconds_ago, NOW - seconds_ago))
|
|
|
|
def run_main(self, argv=(), env=None, now=NOW, compress=compress):
|
|
out, err = io.StringIO(), io.StringIO()
|
|
with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
|
|
code = main.main(list(argv), env or {}, self.home, lambda: now, compress)
|
|
return code, out.getvalue(), err.getvalue()
|
|
|
|
def kept(self):
|
|
return sorted(str(path.relative_to(self.home)) for path in self.home.rglob("*") if path.is_file())
|
|
|
|
def test_gzips_the_archives_transcripts_and_every_review_file_last_written_over_30_days_ago(self):
|
|
code, out, err = self.run_main()
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertEqual(self.kept(), [
|
|
".claude/loop-claude-transcripts/proj/c1/a.jsonl.gz",
|
|
".claude/loop-claude-transcripts/proj/c1/a.outcomes.md",
|
|
".claude/loop-claude-transcripts/proj/c1/b.jsonl",
|
|
".claude/loop-claude-transcripts/proj/c1/session/s/subagents/agent-a.jsonl.gz",
|
|
".claude/loop-claude-transcripts/proj/c1/session/s/subagents/agent-a.meta.json",
|
|
".local/state/larv-review/code/proj-item-1/branch-1.diff",
|
|
".local/state/larv-review/code/proj-item-1/probe/out.js.gz",
|
|
".local/state/larv-review/code/proj-item-1/stability-round-1.md.gz",
|
|
])
|
|
self.assertEqual(gzip.decompress((self.archive / "a.jsonl.gz").read_bytes()), b"a.jsonl\n")
|
|
self.assertEqual(out, "Compressed 4 files.\n")
|
|
self.assertEqual(self.run_main(), (0, "Compressed 0 files.\n", ""))
|
|
|
|
def test_keeps_a_file_last_written_exactly_30_days_ago_plain(self):
|
|
self.write(self.archive / "b.jsonl", 30 * DAY)
|
|
self.run_main()
|
|
self.assertTrue((self.archive / "b.jsonl").is_file())
|
|
|
|
def test_keeps_a_file_copied_today_with_its_old_times_plain(self):
|
|
now = time.time()
|
|
os.utime(self.archive / "a.jsonl", (now - 31 * DAY, now - 31 * DAY))
|
|
self.assertEqual(self.run_main(now=now), (0, "Compressed 0 files.\n", ""))
|
|
self.assertTrue((self.archive / "a.jsonl").is_file())
|
|
|
|
def test_measures_the_30_days_from_the_clock_it_is_given(self):
|
|
self.assertEqual(self.run_main(now=NOW), (0, "Compressed 4 files.\n", ""))
|
|
|
|
def test_walks_on_past_a_gzip_a_link_and_a_file_removed_while_it_walks(self):
|
|
gone = mock.Mock(**{"is_symlink.return_value": False, "stat.side_effect": FileNotFoundError})
|
|
# Mock(name=...) names the mock itself, so the path's name is set after.
|
|
gone.name = "gone.jsonl"
|
|
packed = self.archive / "c.jsonl.gz"
|
|
packed.write_bytes(b"")
|
|
link = self.archive / "d.jsonl"
|
|
link.symlink_to(self.archive / "a.jsonl")
|
|
kept = self.archive / "a.jsonl"
|
|
root = mock.Mock(**{"rglob.return_value": [packed, link, gone, kept]})
|
|
self.assertEqual(main.old_files(root, "*.jsonl", NOW), [kept])
|
|
|
|
def test_reads_the_archive_where_loop_claude_transcripts_puts_it(self):
|
|
moved = self.home / "elsewhere"
|
|
(self.home / ".claude" / "loop-claude-transcripts").rename(moved)
|
|
code, _, err = self.run_main(env={"LOOP_CLAUDE_TRANSCRIPTS": str(moved)})
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertTrue((moved / "proj" / "c1" / "a.jsonl.gz").is_file())
|
|
|
|
def test_runs_where_neither_folder_exists_yet(self):
|
|
with tempfile.TemporaryDirectory() as empty:
|
|
self.home = pathlib.Path(empty)
|
|
self.assertEqual(self.run_main(), (0, "Compressed 0 files.\n", ""))
|
|
|
|
def test_stops_at_the_first_failure_keeping_that_file_and_every_later_one(self):
|
|
code, out, err = self.run_main(compress=lambda path: Failure("could not compress x: full"))
|
|
self.assertEqual((code, out, err), (1, "", "could not compress x: full\n"))
|
|
self.assertTrue((self.archive / "a.jsonl").is_file())
|
|
|
|
def test_prints_its_help_and_refuses_other_arguments(self):
|
|
for flag in ("--help", "-h"):
|
|
code, out, _ = self.run_main([flag])
|
|
self.assertEqual(code, 0)
|
|
self.assertTrue(out.startswith("Gzip each file"), out)
|
|
self.assertEqual(self.run_main(["x", "y"]), (1, "", "unknown arguments x y; usage: compress-archives\n"))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|