496 lines
22 KiB
Python
496 lines
22 KiB
Python
from __future__ import annotations
|
||
|
||
import json
|
||
import uuid
|
||
|
||
import pytest
|
||
|
||
from codexpi.codex_service import INTERRUPTED_WORKER_REASON, CodexManager
|
||
from codexpi.database import Database, utcnow
|
||
from codexpi.remediation_service import (
|
||
AutonomousRemediationService,
|
||
RemediationConflict,
|
||
normalize_name,
|
||
parse_self_repair_verdict,
|
||
parse_supervision_verdict,
|
||
)
|
||
|
||
|
||
def plan_step(target: str = "NASflix") -> dict:
|
||
return {
|
||
"id": "step-one",
|
||
"order": 1,
|
||
"phase": 1,
|
||
"phaseLabel": "Mesurer",
|
||
"target": target,
|
||
"aliases": ["NASFLIX"],
|
||
"title": "Réduire la charge",
|
||
"summary": "Mesurer puis corriger la charge du projet.",
|
||
"risk": "code",
|
||
"prompt": "Inspecter les traitements de fond, appliquer une correction bornée et vérifier par des tests reproductibles. " * 2,
|
||
}
|
||
|
||
|
||
def service_env(tmp_path):
|
||
database = Database(tmp_path / "codexpi.db")
|
||
database.initialize()
|
||
master_path = tmp_path / "master"
|
||
target_path = tmp_path / "nasflix"
|
||
master_path.mkdir()
|
||
target_path.mkdir()
|
||
master_id = str(uuid.uuid4())
|
||
target_id = str(uuid.uuid4())
|
||
database.execute(
|
||
"INSERT INTO projects(id,name,path,owner_id,full_access,execution_group,created_at) VALUES(?,?,?,?,?,?,?)",
|
||
(master_id, "Agent maître", str(master_path), None, 1, "__global_agent__", utcnow()),
|
||
)
|
||
database.execute(
|
||
"INSERT INTO projects(id,name,path,owner_id,full_access,created_at) VALUES(?,?,?,?,?,?)",
|
||
(target_id, "NASflix", str(target_path), "owner-1", 0, utcnow()),
|
||
)
|
||
codex = CodexManager(database, tmp_path / "data", "/bin/true")
|
||
codex._spawn = lambda *args, **kwargs: 4242
|
||
return database, AutonomousRemediationService(database, codex)
|
||
|
||
|
||
def finish_queue(database: Database, queue_id: str, content: str) -> str:
|
||
queue = database.one("SELECT * FROM prompt_queue WHERE id=?", (queue_id,))
|
||
database.execute("UPDATE prompt_queue SET status='done',finished_at=? WHERE id=?", (utcnow(), queue_id))
|
||
database.execute("UPDATE conversations SET status='completed',worker_pid=NULL,updated_at=? WHERE id=?", (utcnow(), queue["conversation_id"]))
|
||
database.execute(
|
||
"INSERT INTO messages(id,conversation_id,role,content,metadata,created_at) VALUES(?,?,?,?,?,?)",
|
||
(str(uuid.uuid4()), queue["conversation_id"], "assistant", content, json.dumps({"queue_id": queue_id, "actions": [], "files": []}), utcnow()),
|
||
)
|
||
return queue_id
|
||
|
||
|
||
def finish_active(database: Database, run_id: str, content: str) -> str:
|
||
run = database.one("SELECT * FROM remediation_runs WHERE id=?", (run_id,))
|
||
return finish_queue(database, run["active_queue_id"], content)
|
||
|
||
|
||
def add_self_project(database: Database, root) -> str:
|
||
path = root / "codexpi-self"
|
||
path.mkdir()
|
||
project_id = str(uuid.uuid4())
|
||
database.execute(
|
||
"INSERT INTO projects(id,name,path,owner_id,full_access,created_at) VALUES(?,?,?,?,?,?)",
|
||
(project_id, "CodexPi (Self)", str(path), "owner-1", 1, utcnow()),
|
||
)
|
||
return project_id
|
||
|
||
|
||
def test_supervision_marker_is_strict_and_accent_insensitive():
|
||
assert normalize_name("Agent Bibliothécaire") == "agentbibliothecaire"
|
||
verdict = parse_supervision_verdict('Rapport\nCODEXPI_SUPERVISION {"decision":"correct","feedback":"Rejouer les tests"}')
|
||
assert verdict == {"decision": "correct", "feedback": "Rejouer les tests"}
|
||
assert parse_supervision_verdict("approuvé sans marqueur") is None
|
||
|
||
|
||
def test_self_repair_marker_is_strict_and_bounded():
|
||
verdict = parse_self_repair_verdict(
|
||
'Rapport\nCODEXPI_SELF_REPAIR {"decision":"fixed","feedback":"Plan corrigé",'
|
||
'"prompt_addendum":"Accepter une maintenance bornée."}'
|
||
)
|
||
assert verdict == {
|
||
"decision": "fixed",
|
||
"feedback": "Plan corrigé",
|
||
"prompt_addendum": "Accepter une maintenance bornée.",
|
||
}
|
||
assert parse_self_repair_verdict('CODEXPI_SELF_REPAIR {"decision":"ignore"}') is None
|
||
|
||
|
||
def test_block_dispatches_codexpi_self_without_replacing_existing_threads(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
self_project_id = add_self_project(database, tmp_path)
|
||
run = service.start("owner-1", [plan_step()])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
target_conversation = service.detail(run["id"], "owner-1")["steps"][0]["conversation_id"]
|
||
finish_active(database, run["id"], "La protection persistante manque.")
|
||
service.tick()
|
||
finish_active(
|
||
database,
|
||
run["id"],
|
||
'CODEXPI_SUPERVISION {"decision":"block","feedback":"Corriger le contrat de reprise"}',
|
||
)
|
||
service.tick()
|
||
|
||
blocked = service.detail(run["id"], "owner-1")
|
||
repair = blocked["self_repair"]
|
||
assert blocked["status"] == "BLOCKED"
|
||
assert blocked["steps"][0]["conversation_id"] == target_conversation
|
||
assert repair["status"] == "RUNNING"
|
||
assert repair["project_id"] == self_project_id
|
||
assert repair["conversation_id"] != target_conversation
|
||
queued = database.one("SELECT content FROM prompt_queue WHERE id=?", (repair["queue_id"],))
|
||
assert "Corriger le contrat de reprise" in queued["content"]
|
||
assert "Ne contourne jamais" in queued["content"]
|
||
assert any(event["kind"] == "self_repair.started" for event in blocked["events"])
|
||
|
||
|
||
def test_successful_self_repair_rebases_and_resumes_the_same_step(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
add_self_project(database, tmp_path)
|
||
run = service.start("owner-1", [plan_step()])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
working = service.detail(run["id"], "owner-1")
|
||
target_conversation = working["steps"][0]["conversation_id"]
|
||
finish_active(database, run["id"], "Le plan impose deux contraintes contradictoires.")
|
||
service.tick()
|
||
finish_active(
|
||
database,
|
||
run["id"],
|
||
'CODEXPI_SUPERVISION {"decision":"block","feedback":"Contradiction du plan"}',
|
||
)
|
||
service.tick()
|
||
repair = service.detail(run["id"], "owner-1")["self_repair"]
|
||
|
||
finish_queue(
|
||
database,
|
||
repair["queue_id"],
|
||
'Correction et tests terminés.\nCODEXPI_SELF_REPAIR '
|
||
'{"decision":"fixed","feedback":"Le contrat distingue maintenance et perte de données.",'
|
||
'"prompt_addendum":"Une courte maintenance réversible est autorisée sans perte de données."}',
|
||
)
|
||
assert service.tick()["state"] == "self_repair_processed"
|
||
|
||
resumed = service.detail(run["id"], "owner-1")
|
||
assert resumed["status"] == "RUNNING"
|
||
assert resumed["stage"] == "AGENT"
|
||
assert resumed["steps"][0]["status"] == "CORRECTING"
|
||
assert resumed["steps"][0]["conversation_id"] == target_conversation
|
||
assert resumed["steps"][0]["attempts"] == 2
|
||
assert "courte maintenance réversible" in resumed["steps"][0]["prompt"]
|
||
assert resumed["self_repair"]["status"] == "SUCCEEDED"
|
||
assert any(event["kind"] == "self_repair.resumed" for event in resumed["events"])
|
||
|
||
|
||
def test_self_repair_can_require_the_owner_without_retrying_the_chantier(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
add_self_project(database, tmp_path)
|
||
run = service.start("owner-1", [plan_step()])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"block","feedback":"Secret externe requis"}')
|
||
service.tick()
|
||
repair = service.detail(run["id"], "owner-1")["self_repair"]
|
||
finish_queue(
|
||
database,
|
||
repair["queue_id"],
|
||
'CODEXPI_SELF_REPAIR {"decision":"needs_user","feedback":"Un secret externe doit être fourni",'
|
||
'"prompt_addendum":""}',
|
||
)
|
||
service.tick()
|
||
|
||
blocked = service.detail(run["id"], "owner-1")
|
||
assert blocked["status"] == "BLOCKED"
|
||
assert blocked["self_repair"]["status"] == "NEEDS_USER"
|
||
assert blocked["self_repair"]["feedback"] == "Un secret externe doit être fourni"
|
||
|
||
|
||
def test_self_repair_keeps_deployment_approval_blocked_without_completing_the_step(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
add_self_project(database, tmp_path)
|
||
run = service.start("owner-1", [plan_step(target="Aloe")])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
finish_active(database, run["id"], "Les manifests et les contrôles dry-run sont valides.")
|
||
service.tick()
|
||
finish_active(
|
||
database,
|
||
run["id"],
|
||
'CODEXPI_SUPERVISION {"decision":"block","feedback":"Le déploiement et le redémarrage exigent la validation distincte du propriétaire"}',
|
||
)
|
||
service.tick()
|
||
repair = service.detail(run["id"], "owner-1")["self_repair"]
|
||
|
||
finish_queue(
|
||
database,
|
||
repair["queue_id"],
|
||
'CODEXPI_SELF_REPAIR {"decision":"needs_user","feedback":"Validation propriétaire requise avant déploiement ou redémarrage",'
|
||
'"prompt_addendum":""}',
|
||
)
|
||
assert service.tick()["state"] == "self_repair_processed"
|
||
|
||
blocked = service.detail(run["id"], "owner-1")
|
||
assert blocked["status"] == "BLOCKED"
|
||
assert blocked["steps"][0]["status"] == "BLOCKED"
|
||
assert blocked["steps"][0]["finished_at"] is None
|
||
assert blocked["self_repair"]["status"] == "NEEDS_USER"
|
||
assert blocked["self_repair"]["prompt_addendum"] == ""
|
||
|
||
resumed = service.resume("owner-1")
|
||
assert resumed["status"] == "RUNNING"
|
||
assert resumed["stage"] == "AGENT"
|
||
assert resumed["self_repair"]["status"] == "SUPERSEDED"
|
||
assert any(event["kind"] == "self_repair.owner_resolved" for event in resumed["events"])
|
||
|
||
|
||
def test_interrupted_supervisor_restarts_review_without_replaying_project_work(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
run = service.start("owner-1", [plan_step(target="Aloe")])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
working = service.detail(run["id"], "owner-1")
|
||
conversation_id = working["steps"][0]["conversation_id"]
|
||
finish_active(database, run["id"], "Déploiement réversible terminé avec mesures avant/après.")
|
||
service.tick()
|
||
reviewing = service.detail(run["id"], "owner-1")
|
||
interrupted_queue_id = reviewing["active_queue_id"]
|
||
database.execute(
|
||
"UPDATE prompt_queue SET status='failed',error=?,finished_at=? WHERE id=?",
|
||
(INTERRUPTED_WORKER_REASON, utcnow(), interrupted_queue_id),
|
||
)
|
||
|
||
assert service.tick()["state"] == "processed"
|
||
|
||
restarted = service.detail(run["id"], "owner-1")
|
||
assert restarted["status"] == "RUNNING"
|
||
assert restarted["stage"] == "SUPERVISOR"
|
||
assert restarted["active_queue_id"] != interrupted_queue_id
|
||
assert restarted["steps"][0]["status"] == "REVIEWING"
|
||
assert restarted["steps"][0]["attempts"] == 1
|
||
assert restarted["steps"][0]["conversation_id"] == conversation_id
|
||
assert restarted["self_repair"] is None
|
||
retry = database.one("SELECT content FROM prompt_queue WHERE id=?", (restarted["active_queue_id"],))
|
||
assert "Reprends uniquement l’inspection" in retry["content"]
|
||
assert "Ne relance aucune modification" in retry["content"]
|
||
assert any(event["kind"] == "master.review_restarted" for event in restarted["events"])
|
||
|
||
|
||
def test_self_repair_of_interrupted_supervisor_resumes_review_not_agent(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
add_self_project(database, tmp_path)
|
||
run = service.start("owner-1", [plan_step(target="Aloe")])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
finish_active(database, run["id"], "Déploiement réversible terminé avec mesures avant/après.")
|
||
service.tick()
|
||
reviewing = service.detail(run["id"], "owner-1")
|
||
project_attempts = reviewing["steps"][0]["attempts"]
|
||
service._block(run["id"], INTERRUPTED_WORKER_REASON, "step-one")
|
||
repair = service.detail(run["id"], "owner-1")["self_repair"]
|
||
finish_queue(
|
||
database,
|
||
repair["queue_id"],
|
||
'CODEXPI_SELF_REPAIR {"decision":"fixed","feedback":"Reprise de revue bornée testée",'
|
||
'"prompt_addendum":""}',
|
||
)
|
||
|
||
assert service.tick()["state"] == "self_repair_processed"
|
||
|
||
resumed = service.detail(run["id"], "owner-1")
|
||
assert resumed["status"] == "RUNNING"
|
||
assert resumed["stage"] == "SUPERVISOR"
|
||
assert resumed["steps"][0]["status"] == "REVIEWING"
|
||
assert resumed["steps"][0]["attempts"] == project_attempts
|
||
queued = database.one("SELECT content FROM prompt_queue WHERE id=?", (resumed["active_queue_id"],))
|
||
assert "Reprends uniquement l’inspection" in queued["content"]
|
||
|
||
|
||
def test_unexpected_runner_crash_is_sent_to_codexpi_self(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
add_self_project(database, tmp_path)
|
||
run = service.start("owner-1", [plan_step()])
|
||
|
||
def crash(_run):
|
||
raise RuntimeError("plantage inattendu du moteur")
|
||
|
||
service._process = crash
|
||
result = service.tick()
|
||
|
||
assert result["state"] == "blocked"
|
||
blocked = service.detail(run["id"], "owner-1")
|
||
assert blocked["status"] == "BLOCKED"
|
||
assert "plantage inattendu" in blocked["error"]
|
||
assert blocked["self_repair"]["status"] == "RUNNING"
|
||
queued = database.one("SELECT content FROM prompt_queue WHERE id=?", (blocked["self_repair"]["queue_id"],))
|
||
assert "plantage inattendu du moteur" in queued["content"]
|
||
|
||
|
||
def test_upgrade_recovers_a_legacy_block_and_rebuilds_its_supervisor_stage(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
add_self_project(database, tmp_path)
|
||
run = service.start("owner-1", [plan_step()])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
finish_active(database, run["id"], "Travail projet terminé avec preuves.")
|
||
service.tick()
|
||
reviewing = service.detail(run["id"], "owner-1")
|
||
assert reviewing["stage"] == "SUPERVISOR"
|
||
queue_id = reviewing["active_queue_id"]
|
||
queue = database.one("SELECT conversation_id FROM prompt_queue WHERE id=?", (queue_id,))
|
||
stamp = utcnow()
|
||
database.execute(
|
||
"UPDATE prompt_queue SET status='failed',error=?,finished_at=? WHERE id=?",
|
||
("thread-store conflict: already has an active writer", stamp, queue_id),
|
||
)
|
||
database.execute(
|
||
"UPDATE conversations SET status='failed',worker_pid=NULL,updated_at=? WHERE id=?",
|
||
(stamp, queue["conversation_id"]),
|
||
)
|
||
database.execute(
|
||
"UPDATE remediation_runs SET status='BLOCKED',stage='IDLE',error=?,lease_owner=NULL,lease_until=NULL,"
|
||
"finished_at=?,updated_at=? WHERE id=?",
|
||
("thread-store conflict: already has an active writer", stamp, stamp, run["id"]),
|
||
)
|
||
database.execute(
|
||
"UPDATE remediation_step_runs SET status='BLOCKED',feedback=?,updated_at=? WHERE run_id=? AND step_id=?",
|
||
("thread-store conflict", stamp, run["id"], "step-one"),
|
||
)
|
||
|
||
upgraded = AutonomousRemediationService(database, service.codex)
|
||
result = upgraded.tick()
|
||
|
||
assert result["state"] == "self_repair_recovered"
|
||
assert result["blocked_stage"] == "SUPERVISOR"
|
||
recovered = upgraded.detail(run["id"], "owner-1")
|
||
assert recovered["self_repair"]["status"] == "RUNNING"
|
||
assert recovered["self_repair"]["blocked_stage"] == "SUPERVISOR"
|
||
assert any(event["kind"] == "self_repair.catchup_started" for event in recovered["events"])
|
||
|
||
|
||
def test_master_and_project_ping_pong_runs_until_final_report(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
created = service.start("owner-1", [plan_step()])
|
||
run_id = created["id"]
|
||
assert created["stage"] == "PLAN_REVIEW"
|
||
assert created["steps"][0]["status"] == "PENDING"
|
||
|
||
finish_active(database, run_id, 'Plan cohérent.\nCODEXPI_SUPERVISION {"decision":"approve","feedback":"Ordre validé"}')
|
||
assert service.tick()["state"] == "processed"
|
||
running = service.detail(run_id, "owner-1")
|
||
assert running["stage"] == "AGENT"
|
||
assert running["steps"][0]["status"] == "WORKING"
|
||
first_conversation = running["steps"][0]["conversation_id"]
|
||
|
||
finish_active(database, run_id, "Correction appliquée, mais preuve partielle.")
|
||
service.tick()
|
||
reviewing = service.detail(run_id, "owner-1")
|
||
assert reviewing["stage"] == "SUPERVISOR"
|
||
assert reviewing["steps"][0]["status"] == "REVIEWING"
|
||
|
||
finish_active(database, run_id, 'Preuve insuffisante.\nCODEXPI_SUPERVISION {"decision":"correct","feedback":"Ajouter la mesure avant/après"}')
|
||
service.tick()
|
||
correcting = service.detail(run_id, "owner-1")
|
||
assert correcting["stage"] == "AGENT"
|
||
assert correcting["correction_round"] == 1
|
||
assert correcting["steps"][0]["status"] == "CORRECTING"
|
||
assert correcting["steps"][0]["conversation_id"] == first_conversation
|
||
assert correcting["steps"][0]["attempts"] == 2
|
||
|
||
finish_active(database, run_id, "Correction complète avec mesures et tests réussis.")
|
||
service.tick()
|
||
finish_active(database, run_id, 'Résultat vérifié.\nCODEXPI_SUPERVISION {"decision":"approve","feedback":"Mesures et tests conformes"}')
|
||
service.tick()
|
||
finalizing = service.detail(run_id, "owner-1")
|
||
assert finalizing["stage"] == "FINAL_REVIEW"
|
||
assert finalizing["steps"][0]["status"] == "APPROVED"
|
||
|
||
finish_active(database, run_id, "Synthèse finale du chantier.")
|
||
service.tick()
|
||
completed = service.detail(run_id, "owner-1")
|
||
assert completed["status"] == "COMPLETED"
|
||
assert completed["stage"] == "IDLE"
|
||
assert any(event["kind"] == "run.completed" for event in completed["events"])
|
||
|
||
|
||
def test_only_one_autonomous_run_can_be_active(tmp_path):
|
||
_, service = service_env(tmp_path)
|
||
service.start("owner-1", [plan_step()])
|
||
with pytest.raises(RemediationConflict, match="déjà en cours"):
|
||
service.start("owner-1", [plan_step()])
|
||
|
||
|
||
def test_blocked_run_resumes_in_the_existing_project_conversation(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
run = service.start("owner-1", [plan_step()])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
working = service.detail(run["id"], "owner-1")
|
||
conversation_id = working["steps"][0]["conversation_id"]
|
||
finish_active(database, run["id"], "Accès technique indisponible.")
|
||
service.tick()
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"block","feedback":"Canal manquant"}')
|
||
service.tick()
|
||
assert service.detail(run["id"], "owner-1")["status"] == "BLOCKED"
|
||
|
||
resumed = service.resume("owner-1")
|
||
assert resumed["status"] == "RUNNING"
|
||
assert resumed["stage"] == "AGENT"
|
||
assert resumed["steps"][0]["status"] == "CORRECTING"
|
||
assert resumed["steps"][0]["conversation_id"] == conversation_id
|
||
assert resumed["steps"][0]["attempts"] == 2
|
||
assert any(event["kind"] == "run.resumed" for event in resumed["events"])
|
||
|
||
|
||
def test_blocked_run_can_rebase_prompts_without_replacing_threads_or_permissions(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
original = plan_step()
|
||
run = service.start("owner-1", [original])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
working = service.detail(run["id"], "owner-1")
|
||
conversation_id = working["steps"][0]["conversation_id"]
|
||
finish_active(database, run["id"], "Certaines métriques sont refusées par le noyau.")
|
||
service.tick()
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"block","feedback":"Critère impossible"}')
|
||
service.tick()
|
||
database.execute("UPDATE remediation_runs SET correction_round=3 WHERE id=?", (run["id"],))
|
||
|
||
revised = {**original, "prompt": original["prompt"] + " Accepter une couverture explicitement qualifiée sans modifier les droits."}
|
||
resumed = service.resume("owner-1", [revised])
|
||
|
||
assert resumed["status"] == "RUNNING"
|
||
assert resumed["correction_round"] == 0
|
||
assert resumed["steps"][0]["prompt"] == revised["prompt"]
|
||
assert resumed["steps"][0]["conversation_id"] == conversation_id
|
||
queued = database.one("SELECT content FROM prompt_queue WHERE id=?", (resumed["active_queue_id"],))
|
||
assert revised["prompt"] in queued["content"]
|
||
event = next(item for item in resumed["events"] if item["kind"] == "run.resumed")
|
||
assert event["details"]["plan_rebased"] is True
|
||
|
||
|
||
def test_rebase_refuses_to_change_target_or_risk(tmp_path):
|
||
database, service = service_env(tmp_path)
|
||
run = service.start("owner-1", [plan_step()])
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"approve","feedback":"Plan valide"}')
|
||
service.tick()
|
||
finish_active(database, run["id"], "Résultat incomplet.")
|
||
service.tick()
|
||
finish_active(database, run["id"], 'CODEXPI_SUPERVISION {"decision":"block","feedback":"Étape bloquée"}')
|
||
service.tick()
|
||
assert service.detail(run["id"], "owner-1")["status"] == "BLOCKED"
|
||
|
||
changed = {**plan_step(), "risk": "production"}
|
||
with pytest.raises(RemediationConflict, match="ordre, la cible ou le risque"):
|
||
service.resume("owner-1", [changed])
|
||
|
||
|
||
def test_owner_can_start_and_read_the_autonomous_run_through_the_api(logged_in, monkeypatch):
|
||
client, app, projects, _, headers = logged_in
|
||
owner_id = str(app.state.db.one("SELECT id FROM users LIMIT 1")["id"])
|
||
master_path = projects / "master"
|
||
target_path = projects / "nasflix"
|
||
master_path.mkdir()
|
||
target_path.mkdir()
|
||
app.state.db.execute(
|
||
"INSERT INTO projects(id,name,path,owner_id,full_access,execution_group,created_at) VALUES(?,?,?,?,?,?,?)",
|
||
(str(uuid.uuid4()), "Agent maître", str(master_path), None, 1, "__global_agent__", utcnow()),
|
||
)
|
||
app.state.db.execute(
|
||
"INSERT INTO projects(id,name,path,owner_id,created_at) VALUES(?,?,?,?,?)",
|
||
(str(uuid.uuid4()), "NASflix", str(target_path), owner_id, utcnow()),
|
||
)
|
||
monkeypatch.setattr(app.state.codex, "detect", lambda *args: "/synthetic-agent")
|
||
monkeypatch.setattr(app.state.codex, "_spawn", lambda *args: 4242)
|
||
|
||
assert client.get("/api/resource-remediation").json()["status"] == "NOT_STARTED"
|
||
response = client.post("/api/resource-remediation/start", headers=headers, json={"steps": [plan_step()]})
|
||
assert response.status_code == 201, response.text
|
||
assert response.json()["stage"] == "PLAN_REVIEW"
|
||
assert response.json()["master_conversation_id"]
|
||
current = client.get("/api/resource-remediation")
|
||
assert current.status_code == 200
|
||
assert current.json()["status"] == "RUNNING"
|