Squash Odysseus development history

tests/test_manage_tasks_owner_scope.py

@@ -13,6 +13,7 @@ permissive than the reader.
 
 import json
 import tempfile
+from datetime import datetime
 
 import pytest
 from sqlalchemy import create_engine
@@ -40,11 +41,11 @@ _TS = sessionmaker(bind=_ENGINE, autoflush=False, autocommit=False)
 cdb.SessionLocal = _TS
 
 
-def _seed(task_id, owner):
+def _seed(task_id, owner, *, name=None):
     db = _TS()
     try:
         db.add(ScheduledTask(
-            id=task_id, owner=owner, name=task_id, prompt="original",
+            id=task_id, owner=owner, name=name or task_id, prompt="original",
             task_type="llm", trigger_type="webhook", status="active",
             output_target="session",
         ))
@@ -61,6 +62,17 @@ def _get(task_id):
         db.close()
 
 
+def _delete(task_id):
+    db = _TS()
+    try:
+        task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+        if task:
+            db.delete(task)
+            db.commit()
+    finally:
+        db.close()
+
+
 @pytest.mark.asyncio
 async def test_edit_denied_on_ownerless_task_for_authenticated_user():
     _seed("ownerless-edit", None)
@@ -137,3 +149,186 @@ async def test_edit_allowed_in_no_login_mode():
     )
     assert out["exit_code"] == 0
     assert _get("shared-task").prompt == "updated"
+
+
+@pytest.mark.asyncio
+async def test_mutation_resolves_exact_name_when_model_puts_name_in_task_id():
+    _seed("task-uuid-for-name-fallback", "alice", name="Daily fixture by name")
+    try:
+        out = await do_manage_tasks(
+            json.dumps({"action": "pause", "task_id": "Daily fixture by name"}),
+            owner="alice",
+        )
+        assert out["exit_code"] == 0
+        assert _get("task-uuid-for-name-fallback").status == "paused"
+    finally:
+        _delete("task-uuid-for-name-fallback")
+
+
+@pytest.mark.asyncio
+async def test_exact_name_fallback_rejects_ambiguous_matches():
+    _seed("ambiguous-task-a", "alice", name="Duplicate task name")
+    _seed("ambiguous-task-b", "alice", name="Duplicate task name")
+    try:
+        out = await do_manage_tasks(
+            json.dumps({"action": "delete", "task_id": "Duplicate task name"}),
+            owner="alice",
+        )
+        assert out["exit_code"] == 1
+        assert out["error"] == "Task name 'Duplicate task name' matched 2 tasks; use task_id"
+        assert _get("ambiguous-task-a") is not None
+        assert _get("ambiguous-task-b") is not None
+    finally:
+        _delete("ambiguous-task-a")
+        _delete("ambiguous-task-b")
+
+
+@pytest.mark.asyncio
+async def test_list_filters_by_exact_name_instead_of_dumping_all_tasks():
+    _seed("list-filter-target", "alice", name="Needle task")
+    _seed("list-filter-other", "alice", name="Other task")
+    try:
+        out = await do_manage_tasks(
+            json.dumps({"action": "list", "name": "Needle task"}),
+            owner="alice",
+        )
+        assert out["exit_code"] == 0
+        assert "Needle task" in out["response"]
+        assert "list-filter-target" in out["response"]
+        assert "Other task" not in out["response"]
+        assert "list-filter-other" not in out["response"]
+    finally:
+        _delete("list-filter-target")
+        _delete("list-filter-other")
+
+
+@pytest.mark.asyncio
+async def test_list_filters_by_pattern_alias():
+    _seed("pattern-filter-target", "alice", name="Pattern needle task")
+    _seed("pattern-filter-other", "alice", name="Unrelated task")
+    try:
+        out = await do_manage_tasks(
+            json.dumps({"action": "list", "pattern": "needle"}),
+            owner="alice",
+        )
+        assert out["exit_code"] == 0
+        assert "Pattern needle task" in out["response"]
+        assert "pattern-filter-target" in out["response"]
+        assert "Unrelated task" not in out["response"]
+        assert "pattern-filter-other" not in out["response"]
+    finally:
+        _delete("pattern-filter-target")
+        _delete("pattern-filter-other")
+
+
+@pytest.mark.asyncio
+async def test_list_filters_by_prompt_alias():
+    _seed("prompt-filter-target", "alice", name="Prompt needle task")
+    _seed("prompt-filter-other", "alice", name="Unrelated task")
+    try:
+        out = await do_manage_tasks(
+            json.dumps({"action": "list", "prompt": "needle"}),
+            owner="alice",
+        )
+        assert out["exit_code"] == 0
+        assert "Prompt needle task" in out["response"]
+        assert "prompt-filter-target" in out["response"]
+        assert "Unrelated task" not in out["response"]
+        assert "prompt-filter-other" not in out["response"]
+    finally:
+        _delete("prompt-filter-target")
+        _delete("prompt-filter-other")
+
+
+@pytest.mark.asyncio
+async def test_one_off_create_persists_utc_date_and_next_run():
+    result = await do_manage_tasks(json.dumps({
+        'action': 'create', 'name': 'dated fixture', 'prompt': 'synthetic',
+        'schedule': 'once', 'scheduled_date': '2099-01-01T09:00:00+09:00',
+    }), owner='alice')
+    assert result['exit_code'] == 0
+    try:
+        row = _get(result['task_id'])
+        assert row.scheduled_date == datetime(2099, 1, 1)
+        assert row.next_run == row.scheduled_date
+    finally:
+        _delete(result['task_id'])
+
+
+@pytest.mark.asyncio
+async def test_one_off_edit_pause_resume_keeps_exact_schedule():
+    result = await do_manage_tasks(json.dumps({
+        'action': 'create', 'name': 'dated edit fixture', 'prompt': 'synthetic',
+        'schedule': 'once', 'scheduled_date': '2099-01-01T00:00:00Z',
+    }), owner='alice')
+    task_id = result['task_id']
+    try:
+        edited = await do_manage_tasks(json.dumps({
+            'action': 'edit', 'task_id': task_id, 'scheduled_date': '2099-01-02T09:00:00+09:00',
+        }), owner='alice')
+        assert edited['exit_code'] == 0
+        assert _get(task_id).scheduled_date == datetime(2099, 1, 2)
+        assert _get(task_id).next_run == datetime(2099, 1, 2)
+        for action in ['pause', 'resume']:
+            out = await do_manage_tasks(json.dumps({'action': action, 'task_id': task_id}), owner='alice')
+            assert out['exit_code'] == 0
+        assert _get(task_id).status == 'active'
+        assert _get(task_id).next_run == datetime(2099, 1, 2)
+        invalid = await do_manage_tasks(json.dumps({
+            'action': 'edit', 'task_id': task_id, 'name': 'must not stick', 'scheduled_date': 'bad-date',
+        }), owner='alice')
+        assert invalid['exit_code'] == 1
+        assert _get(task_id).name == 'dated edit fixture'
+        assert _get(task_id).scheduled_date == datetime(2099, 1, 2)
+    finally:
+        _delete(task_id)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('value', [None, '', 'bad-date', '2000-01-01T00:00:00Z'])
+async def test_invalid_one_off_date_never_creates_an_inert_active_task(value):
+    out = await do_manage_tasks(json.dumps({
+        'action': 'create', 'name': 'invalid dated fixture', 'prompt': 'synthetic',
+        'schedule': 'once', 'scheduled_date': value,
+    }), owner='alice')
+    assert out['exit_code'] == 1
+    with _TS() as db:
+        assert db.query(ScheduledTask).filter(ScheduledTask.name == 'invalid dated fixture').count() == 0
+
+
+@pytest.mark.asyncio
+async def test_task_search_finds_instruction_text_without_other_owner_results():
+    _seed('prompt-only-alice', 'alice', name='Reading fixture')
+    _seed('prompt-only-bob', 'bob', name='Other private fixture')
+    try:
+        for task_id, owner in [('prompt-only-alice', 'alice'), ('prompt-only-bob', 'bob')]:
+            out = await do_manage_tasks(json.dumps({
+                'action': 'edit', 'task_id': task_id, 'prompt': 'Report the lavender inventory',
+            }), owner=owner)
+            assert out['exit_code'] == 0
+        listed = await do_manage_tasks(json.dumps({'action': 'list', 'query': 'lavender'}), owner='alice')
+        assert listed['exit_code'] == 0
+        assert 'Reading fixture' in listed['response']
+        assert 'Other private fixture' not in listed['response']
+    finally:
+        _delete('prompt-only-alice')
+        _delete('prompt-only-bob')
+
+
+@pytest.mark.asyncio
+async def test_list_filters_by_match_alias():
+    _seed("match-filter-target", "alice", name="Match needle task")
+    _seed("match-filter-other", "alice", name="Unrelated task")
+    try:
+        out = await do_manage_tasks(
+            json.dumps({"action": "list", "match": "needle"}),
+            owner="alice",
+        )
+        assert out["exit_code"] == 0
+        assert "Match needle task" in out["response"]
+        assert "match-filter-target" in out["response"]
+        assert "Unrelated task" not in out["response"]
+        assert "match-filter-other" not in out["response"]
+    finally:
+        _delete("match-filter-target")
+        _delete("match-filter-other")