aboutsummaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/fixtures.py46
-rw-r--r--tests/test_cli.py94
-rw-r--r--tests/test_memory.py80
-rw-r--r--tests/test_sessions.py66
-rw-r--r--tests/test_terminal.py78
-rw-r--r--tests/test_webpage.py40
6 files changed, 202 insertions, 202 deletions
diff --git a/tests/fixtures.py b/tests/fixtures.py
index aef1d3f..0e288c8 100644
--- a/tests/fixtures.py
+++ b/tests/fixtures.py
@@ -56,23 +56,23 @@ def write_session(root, project_dir, session_id, events):
def simple_tree(root):
"""A small, varied tree: a chat, an empty one and one without cwd."""
write_session(root, "-home-u-proj", "aaaaaaaa-0000-0000-0000-000000000001", [
- ai_title("Arreglar el build"),
- user("¿por qué falla el build?", at=ts(0)),
- assistant("Miro el log.", tools=[("Bash", {"command": "make"})], at=ts(3)),
- user("gracias", at=ts(12)),
+ ai_title("Fix the build"),
+ user("why does the build fail?", at=ts(0)),
+ assistant("Checking the log.", tools=[("Bash", {"command": "make"})], at=ts(3)),
+ user("thanks", at=ts(12)),
])
write_session(root, "-home-u-proj", "bbbbbbbb-0000-0000-0000-000000000002", [
{"type": "system", "timestamp": ts(0, hour=9), "cwd": "/home/u/proj"},
])
- write_session(root, "-home-u-otro", "cccccccc-0000-0000-0000-000000000003", [
- user("hola", at=ts(0, hour=8), cwd="/home/u/otro"),
+ write_session(root, "-home-u-other", "cccccccc-0000-0000-0000-000000000003", [
+ user("hello", at=ts(0, hour=8), cwd="/home/u/other"),
])
return root
# ──────────────────────────────── memories ────────────────────────────────
-def write_memory(root, project_dir, name, body="cuerpo", desc=None,
+def write_memory(root, project_dir, name, body="body text", desc=None,
kind="project", origin=None, frontmatter=True):
"""Writes <project>/memory/<name>.md and returns its path."""
d = os.path.join(root, project_dir, "memory")
@@ -81,14 +81,14 @@ def write_memory(root, project_dir, name, body="cuerpo", desc=None,
parts = []
if frontmatter:
- campos = ["---", f"name: {name}"]
+ fields = ["---", f"name: {name}"]
if desc is not None:
- campos.append(f"description: {desc}")
- campos += ["metadata:", " node_type: memory", f" type: {kind}"]
+ fields.append(f"description: {desc}")
+ fields += ["metadata:", " node_type: memory", f" type: {kind}"]
if origin:
- campos.append(f" originSessionId: {origin}")
- campos.append("---")
- parts.append("\n".join(campos))
+ fields.append(f" originSessionId: {origin}")
+ fields.append("---")
+ parts.append("\n".join(fields))
parts.append(body)
with open(path, "w", encoding="utf-8") as f:
@@ -102,7 +102,7 @@ def write_index(root, project_dir, names, extra=()):
os.makedirs(d, exist_ok=True)
lines = ["# Memory Index", ""]
for n in list(names) + list(extra):
- lines.append(f"- [{n}]({n}.md) — pista de {n}")
+ lines.append(f"- [{n}]({n}.md) — hint for {n}")
path = os.path.join(d, "MEMORY.md")
with open(path, "w", encoding="utf-8") as f:
f.write("\n".join(lines) + "\n")
@@ -112,22 +112,22 @@ def write_index(root, project_dir, names, extra=()):
def memory_tree(root):
"""Varied memories: indexed, unlisted, and a project without an index."""
write_memory(root, "-home-u-proj", "deploy-docker",
- body="Se despliega con `make up`.\nVer [[roles-db]] y [[no-existe]].",
- desc="Cómo se despliega el proyecto",
+ body="Deployed with `make up`.\nSee [[roles-db]] and [[missing]].",
+ desc="How the project is deployed",
origin="aaaaaaaa-0000-0000-0000-000000000001")
- write_memory(root, "-home-u-proj", "roles-db", body="Roles de la base.",
+ write_memory(root, "-home-u-proj", "roles-db", body="Database roles.",
desc="Roles", kind="reference")
- write_memory(root, "-home-u-proj", "suelta", body="No está en el índice.",
- desc="Huérfana")
+ write_memory(root, "-home-u-proj", "stray", body="Not in the index.",
+ desc="Orphan")
# The index lists two real ones and one that no longer exists.
write_index(root, "-home-u-proj", ["deploy-docker", "roles-db"],
- extra=["borrada-hace-rato"])
+ extra=["deleted-long-ago"])
# Another project with memory but no MEMORY.md.
- write_memory(root, "-home-u-otro", "sin-indice", body="Nadie me indexa.",
- desc="Sin índice", kind="user",
+ write_memory(root, "-home-u-other", "no-index", body="Nobody indexes me.",
+ desc="No index", kind="user",
origin="ffffffff-0000-0000-0000-00000000000f")
# An empty memory/ does not count as a project with memory.
- os.makedirs(os.path.join(root, "-home-u-vacio", "memory"), exist_ok=True)
+ os.makedirs(os.path.join(root, "-home-u-empty", "memory"), exist_ok=True)
return root
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 7b52177..204038c 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -41,41 +41,41 @@ class CliCase(unittest.TestCase):
return code, out.getvalue(), err.getvalue()
-class TestTabla(CliCase):
+class TestTable(CliCase):
def test_lists_the_sessions(self):
simple_tree(self.root)
code, out, _ = self.run_cli()
self.assertEqual(code, 0)
- self.assertIn("Arreglar el build", out)
- self.assertIn("3 sesiones · 2 proyectos", out)
+ self.assertIn("Fix the build", out)
+ self.assertIn("3 sessions · 2 projects", out)
def test_filters_by_text(self):
simple_tree(self.root)
- code, out, _ = self.run_cli("arreglar")
+ code, out, _ = self.run_cli("fix the")
self.assertEqual(code, 0)
- self.assertIn("1 de 3 sesiones", out)
+ self.assertIn("1 of 3 sessions", out)
def test_limits_the_count(self):
simple_tree(self.root)
_, out, _ = self.run_cli("-n", "1")
- self.assertIn("1 de 3 sesiones", out)
+ self.assertIn("1 of 3 sessions", out)
def test_filter_without_results_exits_with_1(self):
simple_tree(self.root)
- code, _, err = self.run_cli("no-existe-esto")
+ code, _, err = self.run_cli("nothing-like-this")
self.assertEqual(code, 1)
- self.assertIn("Ninguna sesión coincide", err)
+ self.assertIn("No session matches", err)
def test_no_claude_directory_exits_with_2(self):
- with unittest.mock.patch.dict(os.environ, {"CLAUDE_CONFIG_DIR": "/no/existe"}):
+ with unittest.mock.patch.dict(os.environ, {"CLAUDE_CONFIG_DIR": "/does/not/exist"}):
code, _, err = self.run_cli()
self.assertEqual(code, 2)
- self.assertIn("no existe", err)
+ self.assertIn("does not exist", err)
def test_no_session_exits_with_1(self):
code, _, err = self.run_cli()
self.assertEqual(code, 1)
- self.assertIn("No hay ninguna sesión", err)
+ self.assertIn("No sessions recorded", err)
class TestExport(CliCase):
@@ -93,7 +93,7 @@ class TestExport(CliCase):
out_path = os.path.join(self.home, "s.html")
code, _, err = self.run_cli("--html", out_path)
self.assertEqual(code, 0)
- self.assertIn("3 sesiones", err)
+ self.assertIn("3 sessions", err)
with open(out_path, encoding="utf-8") as f:
html = f.read()
payload = json.loads(PAYLOAD_RE.findall(html)[0])
@@ -112,23 +112,23 @@ class TestReading(CliCase):
simple_tree(self.root)
code, out, _ = self.run_cli("-s", "1", "--no-pager")
self.assertEqual(code, 0)
- self.assertIn("¿por qué falla el build?", out)
+ self.assertIn("why does the build fail?", out)
def test_show_by_uuid_prefix(self):
simple_tree(self.root)
_, out, _ = self.run_cli("-s", "cccccccc", "--no-pager")
- self.assertIn("hola", out)
+ self.assertIn("hello", out)
def test_show_honours_the_previous_filter(self):
simple_tree(self.root)
- _, out, _ = self.run_cli("-p", "/home/u/otro", "-s", "1", "--no-pager")
- self.assertIn("hola", out)
+ _, out, _ = self.run_cli("-p", "/home/u/other", "-s", "1", "--no-pager")
+ self.assertIn("hello", out)
def test_missing_reference_exits_with_2(self):
simple_tree(self.root)
code, _, err = self.run_cli("-s", "99")
self.assertEqual(code, 2)
- self.assertIn("fuera de rango", err)
+ self.assertIn("out of range", err)
def test_resume_prints_the_command(self):
simple_tree(self.root)
@@ -145,17 +145,17 @@ class TestDeletion(CliCase):
def test_dry_run_touches_nothing(self):
simple_tree(self.root)
- antes = self.paths()
+ before = self.paths()
code, out, _ = self.run_cli("--delete-empty", "--dry-run")
self.assertEqual(code, 0)
- self.assertIn("no se tocó nada", out)
- self.assertEqual(self.paths(), antes)
+ self.assertIn("nothing was touched", out)
+ self.assertEqual(self.paths(), before)
def test_deletes_the_empty_ones(self):
simple_tree(self.root)
code, out, _ = self.run_cli("--delete-empty", "-y")
self.assertEqual(code, 0)
- self.assertIn("1 sesión borrada", out)
+ self.assertIn("1 session deleted", out)
self.assertEqual(self.paths(),
["aaaaaaaa-0000-0000-0000-000000000001.jsonl"])
@@ -170,32 +170,32 @@ class TestDeletion(CliCase):
simple_tree(self.root)
code, out, _ = self.run_cli("-D", "aaaaaaaa", "1", "-y")
self.assertEqual(code, 0)
- self.assertIn("1 sesión borrada", out)
+ self.assertIn("1 session deleted", out)
def test_deleted_one_does_not_come_back_from_cache(self):
simple_tree(self.root)
self.run_cli() # fills the cache
self.run_cli("--delete-empty", "-y")
_, out, _ = self.run_cli()
- self.assertIn("2 sesiones", out)
+ self.assertIn("2 sessions", out)
self.assertNotIn("bbbbbbbb", out)
def test_filter_limits_what_is_deleted(self):
- write_session(self.root, "-home-u-otro", "ffffffff-0000-0000-0000-000000000006",
+ write_session(self.root, "-home-u-other", "ffffffff-0000-0000-0000-000000000006",
[{"type": "system", "timestamp": ts(0)}])
simple_tree(self.root)
code, out, _ = self.run_cli("-p", "/home/u/proj", "--delete-empty", "-y")
self.assertEqual(code, 0)
- self.assertIn("1 sesión borrada", out)
+ self.assertIn("1 session deleted", out)
self.assertTrue(os.path.exists(os.path.join(
- self.root, "-home-u-otro", "ffffffff-0000-0000-0000-000000000006.jsonl")))
+ self.root, "-home-u-other", "ffffffff-0000-0000-0000-000000000006.jsonl")))
def test_nothing_to_delete_warns(self):
write_session(self.root, "-p", "aaaaaaaa-0000-0000-0000-000000000001",
- [user("hola", at=ts(0))])
+ [user("hello", at=ts(0))])
code, _, err = self.run_cli("--delete-empty", "-y")
self.assertEqual(code, 0)
- self.assertIn("No hay sesiones que borrar", err)
+ self.assertIn("No sessions to delete", err)
class TestParser(unittest.TestCase):
@@ -203,29 +203,29 @@ class TestParser(unittest.TestCase):
args = cli.build_parser().parse_args(["--html"])
self.assertEqual(args.html, cli.DEFAULT_HTML)
- def test_html_con_valor(self):
+ def test_html_with_value(self):
self.assertEqual(cli.build_parser().parse_args(["--html", "x.html"]).html,
"x.html")
def test_query_joins_the_words(self):
- args = cli.build_parser().parse_args(["dos", "palabras"])
- self.assertEqual(args.query, ["dos", "palabras"])
+ args = cli.build_parser().parse_args(["two", "words"])
+ self.assertEqual(args.query, ["two", "words"])
class TestMemory(CliCase):
- def test_tabla(self):
+ def test_table(self):
simple_tree(self.root)
memory_tree(self.root)
code, out, _ = self.run_cli("-m")
self.assertEqual(code, 0)
self.assertIn("deploy-docker", out)
- self.assertIn("4 memorias", out)
+ self.assertIn("4 memories", out)
def test_no_memories_warns(self):
simple_tree(self.root)
code, _, err = self.run_cli("-m")
self.assertEqual(code, 1)
- self.assertIn("memorias", err)
+ self.assertIn("memories", err)
def test_filters_by_type(self):
simple_tree(self.root)
@@ -248,13 +248,13 @@ class TestMemory(CliCase):
memory_tree(self.root)
code, out, _ = self.run_cli("-m", "-s", "deploy", "--no-pager")
self.assertEqual(code, 0)
- self.assertIn("Se despliega con", out)
+ self.assertIn("Deployed with", out)
self.assertIn("deploy-docker", out)
def test_show_warns_if_not_indexed(self):
simple_tree(self.root)
memory_tree(self.root)
- _, out, _ = self.run_cli("-m", "-s", "suelta", "--no-pager")
+ _, out, _ = self.run_cli("-m", "-s", "stray", "--no-pager")
self.assertIn("MEMORY.md", out)
def test_check_lists_the_problems(self):
@@ -262,17 +262,17 @@ class TestMemory(CliCase):
memory_tree(self.root)
code, out, _ = self.run_cli("-m", "--check")
self.assertEqual(code, 1) # there are things to look at
- self.assertIn("sin MEMORY.md", out)
- self.assertIn("no-existe", out)
+ self.assertIn("no MEMORY.md", out)
+ self.assertIn("missing", out)
def test_clean_check_exits_zero(self):
simple_tree(self.root)
- write_memory(self.root, "-home-u-proj", "sola", body="sin enlaces")
+ write_memory(self.root, "-home-u-proj", "lone", body="no links")
from .fixtures import write_index
- write_index(self.root, "-home-u-proj", ["sola"])
+ write_index(self.root, "-home-u-proj", ["lone"])
code, out, _ = self.run_cli("-m", "--check")
self.assertEqual(code, 0)
- self.assertIn("Todo en orden", out)
+ self.assertIn("All good", out)
def test_dry_run_deletion_touches_nothing(self):
simple_tree(self.root)
@@ -281,7 +281,7 @@ class TestMemory(CliCase):
"deploy-docker.md")
code, out, _ = self.run_cli("-m", "-D", "deploy", "--dry-run")
self.assertEqual(code, 0)
- self.assertIn("no se tocó nada", out)
+ self.assertIn("nothing was touched", out)
self.assertTrue(os.path.exists(path))
def test_deletes_and_unindexes(self):
@@ -297,7 +297,7 @@ class TestMemory(CliCase):
index = f.read()
self.assertNotIn("deploy-docker.md", index)
self.assertIn("roles-db.md", index)
- self.assertIn("sacadas del índice", out)
+ self.assertIn("removed from the index", out)
def test_unconfirmed_deletion_cancels(self):
simple_tree(self.root)
@@ -307,15 +307,15 @@ class TestMemory(CliCase):
with unittest.mock.patch.object(cli, "confirm", return_value=False):
code, _, err = self.run_cli("-m", "-D", "deploy")
self.assertEqual(code, 1)
- self.assertIn("Cancelado", err)
+ self.assertIn("Cancelled", err)
self.assertTrue(os.path.exists(path))
def test_missing_reference(self):
simple_tree(self.root)
memory_tree(self.root)
- code, _, err = self.run_cli("-m", "-s", "no-existe-nada")
+ code, _, err = self.run_cli("-m", "-s", "no-such-memory")
self.assertEqual(code, 2)
- self.assertIn("ninguna memoria", err)
+ self.assertIn("no memory matches", err)
def test_html_embeds_the_memories(self):
simple_tree(self.root)
@@ -323,7 +323,7 @@ class TestMemory(CliCase):
out_path = os.path.join(self.home, "s.html")
code, _, err = self.run_cli("--html", out_path)
self.assertEqual(code, 0)
- self.assertIn("4 memorias", err)
+ self.assertIn("4 memories", err)
with open(out_path, encoding="utf-8") as f:
payload = json.loads(PAYLOAD_RE.findall(f.read())[0])
self.assertEqual(len(payload["m"]), 4)
diff --git a/tests/test_memory.py b/tests/test_memory.py
index 460d4ec..8761b3e 100644
--- a/tests/test_memory.py
+++ b/tests/test_memory.py
@@ -26,36 +26,36 @@ class MemoryCase(unittest.TestCase):
class TestParsing(MemoryCase):
def test_reads_frontmatter_and_body(self):
- path = write_memory(self.root, "-home-u-proj", "una",
- body="el cuerpo", desc="qué es", kind="feedback",
+ path = write_memory(self.root, "-home-u-proj", "one",
+ body="the body", desc="what it is", kind="feedback",
origin="abc123")
m = memory.read_memory(path, "-home-u-proj")
- self.assertEqual(m["name"], "una")
- self.assertEqual(m["desc"], "qué es")
+ self.assertEqual(m["name"], "one")
+ self.assertEqual(m["desc"], "what it is")
self.assertEqual(m["ty"], "feedback")
self.assertEqual(m["src"], "abc123")
- self.assertEqual(m["body"], "el cuerpo")
+ self.assertEqual(m["body"], "the body")
def test_quoted_description_loses_the_escapes(self):
# Claude writes the description as a YAML string when it contains quotes.
path = write_memory(self.root, "-home-u-proj", "q",
- desc=r'"la máquina \"legion\" y algo"')
+ desc=r'"the \"legion\" machine and more"')
self.assertEqual(memory.read_memory(path, "-home-u-proj")["desc"],
- 'la máquina "legion" y algo')
+ 'the "legion" machine and more')
def test_no_frontmatter_falls_back_to_the_file_name(self):
- path = write_memory(self.root, "-home-u-proj", "pelada",
- body="solo texto", frontmatter=False)
+ path = write_memory(self.root, "-home-u-proj", "bare",
+ body="just text", frontmatter=False)
m = memory.read_memory(path, "-home-u-proj")
- self.assertEqual(m["name"], "pelada")
+ self.assertEqual(m["name"], "bare")
self.assertEqual(m["ty"], "—")
- self.assertEqual(m["body"], "solo texto")
+ self.assertEqual(m["body"], "just text")
def test_collects_links_without_repeats(self):
path = write_memory(self.root, "-home-u-proj", "l",
- body="[[uno]] y [[dos]] y otra vez [[uno]]")
+ body="[[one]] and [[two]] and again [[one]]")
self.assertEqual(memory.read_memory(path, "-home-u-proj")["ln"],
- ["dos", "uno"])
+ ["one", "two"])
class TestLoading(MemoryCase):
@@ -77,16 +77,16 @@ class TestLoading(MemoryCase):
def test_ignores_empty_memory_directories(self):
memory_tree(self.root)
_, mems = self.load_items()
- self.assertNotIn("-home-u-vacio", {m["project_dir"] for m in mems})
+ self.assertNotIn("-home-u-empty", {m["project_dir"] for m in mems})
def test_marks_what_is_in_the_index(self):
memory_tree(self.root)
_, mems = self.load_items()
by_name = {m["name"]: m for m in mems}
self.assertTrue(by_name["deploy-docker"]["ix"])
- self.assertFalse(by_name["suelta"]["ix"])
- self.assertTrue(by_name["suelta"]["hix"])
- self.assertFalse(by_name["sin-indice"]["hix"])
+ self.assertFalse(by_name["stray"]["ix"])
+ self.assertTrue(by_name["stray"]["hix"])
+ self.assertFalse(by_name["no-index"]["hix"])
def test_sorts_by_date_descending(self):
memory_tree(self.root)
@@ -116,15 +116,15 @@ class TestFilters(MemoryCase):
def test_by_project(self):
r = memory.apply_filters(self.mems, project="/home/u/proj")
- self.assertNotIn("sin-indice", [m["name"] for m in r])
+ self.assertNotIn("no-index", [m["name"] for m in r])
def test_query_reaches_the_body(self):
r = memory.apply_filters(self.mems, query="make up")
self.assertEqual([m["name"] for m in r], ["deploy-docker"])
def test_query_also_checks_the_description(self):
- r = memory.apply_filters(self.mems, query="huérfana")
- self.assertEqual([m["name"] for m in r], ["suelta"])
+ r = memory.apply_filters(self.mems, query="orphan")
+ self.assertEqual([m["name"] for m in r], ["stray"])
class TestPick(MemoryCase):
@@ -146,16 +146,16 @@ class TestPick(MemoryCase):
def test_falls_back_to_substring(self):
self.assertEqual(memory.pick(self.mems, "docker")["name"], "deploy-docker")
- def test_sin_coincidencias(self):
+ def test_no_matches(self):
with self.assertRaises(sessions.SessionError):
- memory.pick(self.mems, "nada-que-ver")
+ memory.pick(self.mems, "nothing-like-it")
def test_ambiguous(self):
- write_memory(self.root, "-home-u-proj", "deploy-otro")
+ write_memory(self.root, "-home-u-proj", "deploy-other")
_, mems = self.load_items()
with self.assertRaises(sessions.SessionError) as ctx:
memory.pick(mems, "deploy")
- self.assertIn("ambiguo", str(ctx.exception))
+ self.assertIn("ambiguous", str(ctx.exception))
class TestAudit(MemoryCase):
@@ -167,31 +167,31 @@ class TestAudit(MemoryCase):
self.report = memory.audit(self.mems, self.ss, root=self.root)
def test_project_without_index(self):
- self.assertEqual([m["name"] for m in self.report["sin_indice"]],
- ["sin-indice"])
+ self.assertEqual([m["name"] for m in self.report["no_index"]],
+ ["no-index"])
def test_memory_outside_the_index(self):
- self.assertEqual([m["name"] for m in self.report["sin_listar"]],
- ["suelta"])
+ self.assertEqual([m["name"] for m in self.report["unlisted"]],
+ ["stray"])
def test_index_entry_without_file(self):
- self.assertEqual([n for _, n in self.report["indice_fantasma"]],
- ["borrada-hace-rato"])
+ self.assertEqual([n for _, n in self.report["ghost_entries"]],
+ ["deleted-long-ago"])
def test_broken_link(self):
- broken = [link for _, link in self.report["enlaces_rotos"]]
- self.assertEqual(broken, ["no-existe"]) # [[roles-db]] does resolve
+ broken = [link for _, link in self.report["broken_links"]]
+ self.assertEqual(broken, ["missing"]) # [[roles-db]] does resolve
def test_lost_origin_session(self):
- # deploy-docker points to a session that exists; sin-indice does not.
- self.assertEqual([m["name"] for m in self.report["origen_perdido"]],
- ["sin-indice"])
+ # deploy-docker points to a session that exists; no-index does not.
+ self.assertEqual([m["name"] for m in self.report["lost_source"]],
+ ["no-index"])
def test_consistent_tree_reports_nothing(self):
- is_clean = os.path.join(self._tmp.name, "limpio")
+ is_clean = os.path.join(self._tmp.name, "clean")
os.makedirs(is_clean)
- write_memory(is_clean, "-p", "sola", body="sin enlaces")
- write_index(is_clean, "-p", ["sola"])
+ write_memory(is_clean, "-p", "lone", body="no links")
+ write_index(is_clean, "-p", ["lone"])
mems = memory.load_memories([], root=is_clean)
self.assertEqual(memory.audit_total(memory.audit(mems, [], root=is_clean)), 0)
@@ -217,12 +217,12 @@ class TestDeletion(MemoryCase):
self.assertIn("roles-db", memory.read_index("-home-u-proj", self.root))
def test_delete_one_that_was_not_indexed(self):
- m = self.by_name("suelta")
+ m = self.by_name("stray")
self.assertFalse(memory.delete(m, root=self.root))
self.assertFalse(os.path.exists(memory.memory_path(m, self.root)))
def test_delete_without_memory_md(self):
- m = self.by_name("sin-indice")
+ m = self.by_name("no-index")
self.assertFalse(memory.delete(m, root=self.root))
self.assertFalse(os.path.exists(memory.memory_path(m, self.root)))
diff --git a/tests/test_sessions.py b/tests/test_sessions.py
index 8ad48db..1e10a48 100644
--- a/tests/test_sessions.py
+++ b/tests/test_sessions.py
@@ -25,8 +25,8 @@ class TempRoot(unittest.TestCase):
class TestReadSession(TempRoot):
def test_basic_conversation(self):
path = write_session(self.root, "-p", "11111111-1111-1111-1111-111111111111", [
- user("¿por qué falla?", at=ts(0)),
- assistant("Miro.", tools=[("Bash", {"command": "make test"})], at=ts(5)),
+ user("why does it fail?", at=ts(0)),
+ assistant("Looking.", tools=[("Bash", {"command": "make test"})], at=ts(5)),
])
rec = S.read_session(path)
@@ -37,37 +37,37 @@ class TestReadSession(TempRoot):
self.assertEqual(rec["b"], "main")
self.assertFalse(rec["e"])
self.assertFalse(rec["ai"])
- self.assertEqual(rec["t"], "¿por qué falla?")
+ self.assertEqual(rec["t"], "why does it fail?")
self.assertEqual([m["r"] for m in rec["c"]], ["u", "a", "t"])
self.assertEqual(rec["c"][2]["x"], "Bash: make test")
def test_claude_title_beats_the_first_message(self):
path = write_session(self.root, "-p", "22222222-0000-0000-0000-000000000000", [
- user("arreglá esto", at=ts(0)),
- ai_title("Primer intento"),
- ai_title("Título final"),
+ user("fix this", at=ts(0)),
+ ai_title("First attempt"),
+ ai_title("Final title"),
])
rec = S.read_session(path)
- self.assertEqual(rec["t"], "Título final")
+ self.assertEqual(rec["t"], "Final title")
self.assertTrue(rec["ai"])
def test_ignores_harness_noise(self):
path = write_session(self.root, "-p", "33333333-0000-0000-0000-000000000000", [
user("<command-name>/clear</command-name>", at=ts(0)),
- user("<system-reminder>ojo</system-reminder>", at=ts(1)),
- user("texto real <system-reminder>ojo</system-reminder>", at=ts(2)),
+ user("<system-reminder>note</system-reminder>", at=ts(1)),
+ user("real text <system-reminder>note</system-reminder>", at=ts(2)),
user("meta", at=ts(2), isMeta=True),
- user("de un subagente", at=ts(3), isSidechain=True),
- assistant("respuesta de subagente", at=ts(4), isSidechain=True),
+ user("from a subagent", at=ts(3), isSidechain=True),
+ assistant("subagent reply", at=ts(4), isSidechain=True),
])
rec = S.read_session(path)
self.assertEqual(rec["u"], 1)
self.assertEqual(rec["a"], 0)
- self.assertEqual(rec["c"][0]["x"], "texto real")
+ self.assertEqual(rec["c"][0]["x"], "real text")
def test_tolerates_a_line_cut_in_half(self):
path = write_session(self.root, "-p", "44444444-0000-0000-0000-000000000000", [
- user("primero", at=ts(0)),
+ user("first", at=ts(0)),
])
with open(path, "a", encoding="utf-8") as f:
f.write('{"type": "user", "message": {"content": [{"type": "te')
@@ -92,7 +92,7 @@ class TestReadSession(TempRoot):
def test_short_chat_is_not_claude_p(self):
path = write_session(self.root, "-p", "77777777-0000-0000-0000-000000000000", [
- user("hola", at=ts(0)),
+ user("hello", at=ts(0)),
])
self.assertFalse(S.read_session(path)["n"])
@@ -105,8 +105,8 @@ class TestToolSummary(unittest.TestCase):
def test_falls_back_to_first_string_for_unknown_tool(self):
self.assertEqual(
- S.tool_summary({"name": "Rara", "input": {"n": 1, "q": "algo"}}),
- "Rara: algo")
+ S.tool_summary({"name": "Odd", "input": {"n": 1, "q": "something"}}),
+ "Odd: something")
def test_truncates_long_arguments(self):
out = S.tool_summary({"name": "Bash", "input": {"command": "a" * 500}})
@@ -115,7 +115,7 @@ class TestToolSummary(unittest.TestCase):
def test_no_usable_arguments(self):
self.assertEqual(S.tool_summary({"name": "X", "input": {"n": 1}}), "X")
- self.assertEqual(S.tool_summary({"name": "X", "input": "no es dict"}), "X")
+ self.assertEqual(S.tool_summary({"name": "X", "input": "not a dict"}), "X")
class TestLoad(TempRoot):
@@ -126,7 +126,7 @@ class TestLoad(TempRoot):
def test_infers_the_path_from_another_session_of_the_project(self):
write_session(self.root, "-home-u-proj", "aaaaaaaa-0000-0000-0000-000000000001",
- [user("con cwd", at=ts(0))])
+ [user("with cwd", at=ts(0))])
write_session(self.root, "-home-u-proj", "dddddddd-0000-0000-0000-000000000004",
[{"type": "system", "timestamp": ts(30)}])
orphan = next(s for s in self.load() if s["id"].startswith("dddddddd"))
@@ -134,18 +134,18 @@ class TestLoad(TempRoot):
self.assertTrue(orphan["i"])
def test_no_known_path_keeps_the_directory_name(self):
- write_session(self.root, "-sin-cwd", "eeeeeeee-0000-0000-0000-000000000005",
+ write_session(self.root, "-no-cwd", "eeeeeeee-0000-0000-0000-000000000005",
[{"type": "system", "timestamp": ts(0)}])
s = self.load()[0]
- self.assertEqual(s["p"], "-sin-cwd")
+ self.assertEqual(s["p"], "-no-cwd")
self.assertTrue(s["i"])
- def test_ignora_los_jsonl_de_subagentes(self):
+ def test_ignores_subagent_jsonl_files(self):
simple_tree(self.root)
sub = os.path.join(self.root, "-home-u-proj", "aaaaaaaa-0000-0000-0000-000000000001", "subagents")
os.makedirs(sub)
with open(os.path.join(sub, "agent-1.jsonl"), "w", encoding="utf-8") as f:
- f.write(json.dumps(user("soy un subagente")) + "\n")
+ f.write(json.dumps(user("I am a subagent")) + "\n")
self.assertEqual(len(self.load()), 3)
@@ -159,18 +159,18 @@ class TestCache(TempRoot):
with open(self.cache, encoding="utf-8") as f:
blob = json.load(f)
for entry in blob["entries"].values():
- entry["rec"]["t"] = "vino del caché"
+ entry["rec"]["t"] = "came from the cache"
with open(self.cache, "w", encoding="utf-8") as f:
json.dump(blob, f)
- self.assertEqual(self.load()[0]["t"], "vino del caché")
+ self.assertEqual(self.load()[0]["t"], "came from the cache")
def test_reparses_if_the_file_changed(self):
path = write_session(self.root, "-p", "99999999-0000-0000-0000-000000000009",
[user("original", at=ts(0))])
self.load()
write_session(self.root, "-p", "99999999-0000-0000-0000-000000000009",
- [user("cambiado", at=ts(0)), user("y otro", at=ts(1))])
+ [user("changed", at=ts(0)), user("and another", at=ts(1))])
self.assertEqual(self.load()[0]["u"], 2)
self.assertTrue(os.path.exists(path))
@@ -181,16 +181,16 @@ class TestCache(TempRoot):
blob = json.load(f)
blob["v"] = S.CACHE_VERSION - 1
for entry in blob["entries"].values():
- entry["rec"]["t"] = "no debería verse"
+ entry["rec"]["t"] = "should not show up"
with open(self.cache, "w", encoding="utf-8") as f:
json.dump(blob, f)
- self.assertEqual(self.load()[0]["t"], "Arreglar el build")
+ self.assertEqual(self.load()[0]["t"], "Fix the build")
def test_broken_cache_breaks_nothing(self):
simple_tree(self.root)
with open(self.cache, "w", encoding="utf-8") as f:
- f.write("{esto no es json")
+ f.write("{this is not json")
self.assertEqual(len(self.load()), 3)
def test_no_cache_writes_nothing(self):
@@ -200,7 +200,7 @@ class TestCache(TempRoot):
def test_cache_stores_the_path_without_inferring(self):
write_session(self.root, "-home-u-proj", "aaaaaaaa-0000-0000-0000-000000000001",
- [user("con cwd", at=ts(0))])
+ [user("with cwd", at=ts(0))])
write_session(self.root, "-home-u-proj", "dddddddd-0000-0000-0000-000000000004",
[{"type": "system", "timestamp": ts(30)}])
self.load()
@@ -226,7 +226,7 @@ class TestFilters(TempRoot):
self.sessions = self.load()
def test_by_project(self):
- out = S.apply_filters(self.sessions, project="/home/u/otro")
+ out = S.apply_filters(self.sessions, project="/home/u/other")
self.assertEqual(len(out), 1)
def test_by_conversation_content(self):
@@ -234,7 +234,7 @@ class TestFilters(TempRoot):
self.assertEqual([s["id"][:8] for s in out], ["aaaaaaaa"])
def test_by_title_path_branch_or_uuid(self):
- self.assertEqual(len(S.apply_filters(self.sessions, query="arreglar")), 1)
+ self.assertEqual(len(S.apply_filters(self.sessions, query="fix the")), 1)
self.assertEqual(len(S.apply_filters(self.sessions, query="main")), 2)
self.assertEqual(len(S.apply_filters(self.sessions, query="cccccccc")), 1)
@@ -266,7 +266,7 @@ class TestPick(TempRoot):
def test_ambiguous_prefix(self):
write_session(self.root, "-home-u-proj", "aaaaaaaa-0000-0000-0000-0000000000ff",
- [user("otra más", at=ts(50))])
+ [user("one more", at=ts(50))])
with self.assertRaises(S.SessionError):
S.pick(self.load(), "aaaa")
@@ -290,7 +290,7 @@ class TestParseTs(unittest.TestCase):
def test_returns_none_if_unreadable(self):
self.assertIsNone(S.parse_ts(None))
self.assertIsNone(S.parse_ts(""))
- self.assertIsNone(S.parse_ts("ayer a la tarde"))
+ self.assertIsNone(S.parse_ts("yesterday afternoon"))
class TestRoots(unittest.TestCase):
diff --git a/tests/test_terminal.py b/tests/test_terminal.py
index 6991a85..0446dda 100644
--- a/tests/test_terminal.py
+++ b/tests/test_terminal.py
@@ -22,11 +22,11 @@ class TestStyle(unittest.TestCase):
st = T.Style(True)
self.assertTrue(st.amber.startswith("\x1b["))
- def test_un_color_que_no_existe_es_attribute_error(self):
+ def test_unknown_color_is_attribute_error(self):
with self.assertRaises(AttributeError):
- T.Style(True).fucsia
+ T.Style(True).fuchsia
- def test_from_stream_sin_tty_apaga_el_color(self):
+ def test_from_stream_without_tty_turns_color_off(self):
self.assertFalse(T.Style.from_stream(io.StringIO()).on)
@@ -39,27 +39,27 @@ class TestFormatting(unittest.TestCase):
self.assertEqual(T.fmt_dur(125), "2h05")
def test_fmt_rel(self):
- self.assertEqual(T.fmt_rel(ago(0.2), NOW), "hoy")
- self.assertEqual(T.fmt_rel(ago(1.5), NOW), "ayer")
- self.assertEqual(T.fmt_rel(ago(3), NOW), "hace 3d")
- self.assertEqual(T.fmt_rel(ago(10), NOW), "hace 1sem")
- self.assertEqual(T.fmt_rel(ago(70), NOW), "hace 2mes")
+ self.assertEqual(T.fmt_rel(ago(0.2), NOW), "today")
+ self.assertEqual(T.fmt_rel(ago(1.5), NOW), "yesterday")
+ self.assertEqual(T.fmt_rel(ago(3), NOW), "3d ago")
+ self.assertEqual(T.fmt_rel(ago(10), NOW), "1w ago")
+ self.assertEqual(T.fmt_rel(ago(70), NOW), "2mo ago")
def test_fmt_size(self):
self.assertEqual(T.fmt_size(12.5), "12.5 KB")
self.assertEqual(T.fmt_size(2048), "2.0 MB")
def test_clip(self):
- self.assertEqual(T.clip("hola", 10), "hola")
- self.assertEqual(T.clip("hola mundo", 6), "hola …")
- self.assertEqual(T.clip("con\nsalto", 20), "con salto")
+ self.assertEqual(T.clip("hello", 10), "hello")
+ self.assertEqual(T.clip("hello world", 6), "hello…")
+ self.assertEqual(T.clip("line\nbreak", 20), "line break")
def test_visible_len_ignores_ansi_codes(self):
- self.assertEqual(T.visible_len("\x1b[1mhola\x1b[0m"), 4)
+ self.assertEqual(T.visible_len("\x1b[1mhello\x1b[0m"), 5)
def test_plural(self):
- self.assertEqual(T.plural(1, "sesión", "sesiones"), "1 sesión")
- self.assertEqual(T.plural(2, "sesión", "sesiones"), "2 sesiones")
+ self.assertEqual(T.plural(1, "session", "sessions"), "1 session")
+ self.assertEqual(T.plural(2, "session", "sessions"), "2 sessions")
def test_stripe_without_color_is_a_bar(self):
self.assertEqual(T.stripe(ago(1), NOW, T.Style(False)), "|")
@@ -72,13 +72,13 @@ class TestFormatting(unittest.TestCase):
class TestMarkdown(unittest.TestCase):
def test_strip_md(self):
- self.assertEqual(T.strip_md("## Título"), "Título")
- self.assertEqual(T.strip_md("esto es **fuerte**"), "esto es fuerte")
+ self.assertEqual(T.strip_md("## Title"), "Title")
+ self.assertEqual(T.strip_md("this is **bold**"), "this is bold")
def test_render_block_respects_fences(self):
st = T.Style(False)
- out = T.render_block("texto\n```py\nx = 1\n```\nfin", st, 40, "")
- self.assertIn(" texto", out)
+ out = T.render_block("text\n```py\nx = 1\n```\nend", st, 40, "")
+ self.assertIn(" text", out)
self.assertIn(" x = 1", out)
self.assertNotIn("```py", "".join(out))
@@ -91,22 +91,22 @@ class TestOutput(unittest.TestCase):
def session_item(self, **kw):
s = {
"id": "abcdef01-2345-6789-abcd-ef0123456789",
- "p": "/home/u/proj", "b": "main", "t": "Arreglar el build",
+ "p": "/home/u/proj", "b": "main", "t": "Fix the build",
"ai": True, "n": False, "e": False, "i": False,
"f": ago(1), "l": ago(1), "d": 12, "u": 2, "a": 3, "k": 10.0,</