JiuContinent/company-ai-platform
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

```

Browse Source 
refactor: 移除审批和回写功能模块

移除了整个审批(approvals)和官方回写(writebacks)功能模块，
包括相关模型、路由、服务和配置项。更新了数据库迁移文件，
删除了相关的审批请求表和官方回写运行表。同时从API路由器中
移除了相应的路由，并调整了安全常量和字段验证器以匹配变更。
```
This commit is contained in:
JiuContinent
2026-07-08 17:08:59 +08:00
parent 19e59e83cc
commit 0a153b264a
48 changed files with 135 additions and 2225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

555
tests/test_smoke.py
View File

@@ -9,7 +9,7 @@ from fastapi import HTTPException
from sqlalchemy import select
from app.modules.ai_agent.constants import AIProviderName, AIResponseKey
from app.modules.business.constants import StatusValue
from app.modules.business.constants import BusinessResponseKey, StatusValue
_db = tempfile.NamedTemporaryFile(delete=False, suffix=".db")
_db.close()
@@ -18,12 +18,9 @@ os.environ["DATABASE_URL"] = "sqlite:///" + _db.name.replace("\\", "/")
os.environ["API_KEY"] = "test-key"
os.environ["AUDIT_API_KEY"] = "audit-key"
os.environ["AUDIT_API_ACTOR"] = "audit-manager"
os.environ["APPROVAL_API_KEY"] = "approval-key"
os.environ["APPROVAL_API_ACTOR"] = "approval-manager"
os.environ["FEISHU_APP_ID"] = ""
os.environ["FEISHU_APP_SECRET"] = ""
os.environ["FEISHU_VERIFICATION_TOKEN"] = "test-feishu-token"
os.environ["FEISHU_APPROVAL_APPROVER_IDS"] = json.dumps(["ou_card_approver"])
os.environ["LEGACY_ALLOWED_QUERIES"] = "{}"
os.environ["LEGACY_DATABASE_URL"] = ""
os.environ["LEGACY_PROJECT_QUERY"] = ""
@@ -33,9 +30,9 @@ os.environ["SCHEDULER_ENABLED"] = "false"
from fastapi.testclient import TestClient
from app.core.config import Settings, get_settings
from app.core.database import Base, engine
from app.core.database import Base, SessionLocal, engine
from app.core.pagination import bounded_limit, bounded_offset
from app.core.security import require_api_key, require_approval_api_key, require_audit_api_key
from app.core.security import require_api_key, require_audit_api_key
from app.main import _allow_cors_credentials, app
from app.modules.audit.constants import AUDIT_REDACTED_VALUE
from app.modules.events.constants import (
@@ -46,10 +43,8 @@ from app.modules.events.constants import (
EventType,
)
from app.modules.events.service import EventService
from app.modules.feishu.constants import (
FEISHU_APPROVAL_APPROVER_IDS_REQUIRED,
FEISHU_APPROVER_NOT_ALLOWED,
)
from app.modules.business.registry import get_domain_model
from app.modules.business.service import _model_payload, serialize_model
from app.modules.legacy_mysql.service import LegacyMySQLService
from app.modules.reports.constants import (
LifecycleAttentionKey,
@@ -63,50 +58,40 @@ from app.modules.reports.constants import (
from app.modules.risk.constants import RiskEventActionValue
from app.modules.workflows.constants import WorkflowStatus, WorkflowType
from app.modules.workflows.models import WorkflowInstance
from app.modules.writebacks.constants import WritebackStatus
Base.metadata.create_all(bind=engine)
client = TestClient(app)
headers = {"X-API-Key": "test-key"}
audit_headers = {"X-API-Key": "test-key", "X-Audit-API-Key": "audit-key"}
approval_headers = {"X-API-Key": "test-key", "X-Approval-API-Key": "approval-key"}
def approve_change(
domain: str,
action: str,
payload: dict,
record_id: str | int | None = None,
) -> str:
request_payload: dict[str, object] = {
"domain": domain,
"action": action,
"reason": "pytest approval",
"payload": payload,
}
if record_id is not None:
request_payload["record_id"] = str(record_id)
response = client.post("/api/v1/approvals", headers=headers, json=request_payload)
assert response.status_code == 200
ticket_id = response.json()["ticket_id"]
class SeedResponse:
def __init__(self, payload: dict, status_code: int = 200):
self.status_code = status_code
self._payload = payload
approve_response = client.post(
f"/api/v1/approvals/{ticket_id}/approve",
headers=approval_headers,
json={"comment": "pytest approved"},
)
assert approve_response.status_code == 200
return ticket_id
def json(self) -> dict:
return self._payload
def create_business_record(domain: str, data: dict, actor: str = "pytest"):
ticket_id = approve_change(domain, f"create:{domain}", data)
return client.post(
f"/api/v1/business/{domain}",
headers=headers,
json={"actor": actor, "approval_ticket_id": ticket_id, "data": data},
)
def create_business_record(domain: str, data: dict, actor: str = "pytest") -> SeedResponse:
_ = actor
db = SessionLocal()
try:
model = get_domain_model(domain)
record = model(**_model_payload(domain, model, data))
db.add(record)
db.commit()
db.refresh(record)
return SeedResponse(
{
BusinessResponseKey.DOMAIN: domain,
BusinessResponseKey.DATA: serialize_model(record),
}
)
finally:
db.close()
def teardown_module() -> None:
@@ -243,7 +228,7 @@ def test_v3_event_idempotency_and_workflow_dispatch() -> None:
db.close()
def test_v3_risk_action_creates_workflow() -> None:
def test_v3_risk_action_routes_are_disabled_in_read_only_mode() -> None:
response = create_business_record(
"risk-events",
{
@@ -261,22 +246,10 @@ def test_v3_risk_action_creates_workflow() -> None:
headers=headers,
json={"assigned_to": "risk-owner", "comment": "route to owner"},
)
assert response.status_code == 200
response = client.get(
"/api/v1/workflows",
headers=headers,
params={"workflow_type": WorkflowType.RISK_EVENT_REVIEW},
)
assert response.status_code == 200
workflows = response.json()["items"]
assert any(
item["aggregate_id"] == str(risk_id) and item["status"] == WorkflowStatus.RUNNING
for item in workflows
)
assert response.status_code == 405
def test_v3_writeback_disabled_requires_approval_without_consuming_ticket() -> None:
def test_writeback_and_approval_routes_are_removed() -> None:
response = client.post(
"/api/v1/writebacks",
headers=headers,
@@ -287,15 +260,7 @@ def test_v3_writeback_disabled_requires_approval_without_consuming_ticket() -> N
"payload": {"code": "P-V3-WB", "name": "Writeback target"},
},
)
assert response.status_code == 200
writeback_code = response.json()["data"]["code"]
response = client.post(
f"/api/v1/writebacks/{writeback_code}/submit",
headers=headers,
json={},
)
assert response.status_code == 409
assert response.status_code == 404
response = client.post(
"/api/v1/approvals",
@@ -308,39 +273,7 @@ def test_v3_writeback_disabled_requires_approval_without_consuming_ticket() -> N
"payload": {"code": "P-V3-WB", "name": "Writeback target"},
},
)
assert response.status_code == 200
ticket_id = response.json()["ticket_id"]
response = client.post(
f"/api/v1/approvals/{ticket_id}/approve",
headers=approval_headers,
json={"comment": "approved for disabled adapter test"},
)
assert response.status_code == 200
response = client.post(
f"/api/v1/writebacks/{writeback_code}/submit",
headers=headers,
json={"approval_ticket_id": ticket_id},
)
assert response.status_code == 200
assert response.json()["data"]["status"] == WritebackStatus.DISABLED
response = client.get(f"/api/v1/approvals/{ticket_id}", headers=approval_headers)
assert response.status_code == 200
assert response.json()["status"] == "approved"
response = client.get(
"/api/v1/workflows",
headers=headers,
params={"workflow_type": WorkflowType.OFFICIAL_WRITEBACK},
)
assert response.status_code == 200
workflows = response.json()["items"]
assert any(
item["aggregate_id"] == writeback_code and item["status"] == WorkflowStatus.BLOCKED
for item in workflows
)
assert response.status_code == 404
def test_feishu_webhook_challenge_uses_event_service_verification() -> None:
@@ -373,12 +306,6 @@ def test_api_key_and_feishu_webhook_fail_closed(monkeypatch) -> None:
)
assert response.status_code == 401
monkeypatch.setenv("APPROVAL_API_KEY", "")
get_settings.cache_clear()
with pytest.raises(HTTPException) as approval_exc_info:
require_approval_api_key("approval-key")
assert approval_exc_info.value.status_code == 503
monkeypatch.setenv("AUDIT_API_KEY", "")
get_settings.cache_clear()
with pytest.raises(HTTPException) as audit_exc_info:
@@ -387,7 +314,6 @@ def test_api_key_and_feishu_webhook_fail_closed(monkeypatch) -> None:
finally:
monkeypatch.setenv("API_KEY", "test-key")
monkeypatch.setenv("AUDIT_API_KEY", "audit-key")
monkeypatch.setenv("APPROVAL_API_KEY", "approval-key")
get_settings.cache_clear()
@@ -472,7 +398,6 @@ def test_configured_domain_response_masking(monkeypatch) -> None:
},
)
assert response.status_code == 200
assert response.json()["data"]["amount"] == "[MASKED]"
list_response = client.get("/api/v1/business/expenses", headers=headers)
assert list_response.status_code == 200
@@ -487,8 +412,8 @@ def test_configured_domain_response_masking(monkeypatch) -> None:
get_settings.cache_clear()
def test_business_writes_require_approval_and_reject_read_only_fields() -> None:
blocked_response = client.post(
def test_business_write_routes_are_disabled_in_read_only_mode() -> None:
create_response = client.post(
"/api/v1/business/projects",
headers=headers,
json={
@@ -498,187 +423,21 @@ def test_business_writes_require_approval_and_reject_read_only_fields() -> None:
},
},
)
assert blocked_response.status_code == 409
readonly_payload = {
"code": "P-READONLY-001",
"name": "Readonly project",
"created_at": "2026-07-08T00:00:00",
}
ticket_id = approve_change("projects", "create:projects", readonly_payload)
readonly_response = client.post(
"/api/v1/business/projects",
headers=headers,
json={
"approval_ticket_id": ticket_id,
"data": readonly_payload,
},
)
assert readonly_response.status_code == 422
assert readonly_response.json()["detail"] == "Field 'created_at' is read-only"
def test_approval_gate_for_high_risk_update() -> None:
create_payload = {
"code": "FUND-SMOKE-001",
"name": "Main Account",
"current_balance": 1000,
"safety_line": 500,
}
blocked_create_response = client.post(
"/api/v1/business/fund-accounts",
headers=headers,
json={
"actor": "spoofed-user",
"data": {
"code": "FUND-SMOKE-BLOCKED",
"name": "Blocked Account",
},
},
)
assert blocked_create_response.status_code == 409
create_approval_response = client.post(
"/api/v1/approvals",
headers=headers,
json={
"domain": "fund-accounts",
"action": "create:fund-accounts",
"applicant": "spoofed-user",
"reason": "Smoke test account creation",
"payload": create_payload,
},
)
assert create_approval_response.status_code == 200
assert create_approval_response.json()["applicant"] == "api"
create_ticket_id = create_approval_response.json()["ticket_id"]
approval_list_without_approval_key_response = client.get("/api/v1/approvals", headers=headers)
assert approval_list_without_approval_key_response.status_code == 401
approval_detail_without_approval_key_response = client.get(
f"/api/v1/approvals/{create_ticket_id}",
headers=headers,
)
assert approval_detail_without_approval_key_response.status_code == 401
approval_detail_response = client.get(
f"/api/v1/approvals/{create_ticket_id}",
headers=approval_headers,
)
assert approval_detail_response.status_code == 200
approve_create_response = client.post(
f"/api/v1/approvals/{create_ticket_id}/approve",
headers=approval_headers,
json={"comment": "ok"},
)
assert approve_create_response.status_code == 200
assert approve_create_response.json()["approver"] == "approval-manager"
create_response = client.post(
"/api/v1/business/fund-accounts",
headers=headers,
json={
"actor": "spoofed-user",
"approval_ticket_id": create_ticket_id,
"data": create_payload,
},
)
assert create_response.status_code == 200
record_id = create_response.json()["data"]["id"]
reuse_create_response = client.post(
"/api/v1/business/fund-accounts",
headers=headers,
json={
"approval_ticket_id": create_ticket_id,
"data": {
"code": "FUND-SMOKE-REUSE",
"name": "Reuse Account",
},
},
)
assert reuse_create_response.status_code == 403
blocked_response = client.patch(
f"/api/v1/business/fund-accounts/{record_id}",
headers=headers,
json={"actor": "spoofed-user", "data": {"current_balance": 100}},
)
assert blocked_response.status_code == 409
approval_response = client.post(
"/api/v1/approvals",
headers=headers,
json={
"domain": "fund-accounts",
"record_id": str(record_id),
"action": "update:fund-accounts",
"applicant": "spoofed-user",
"reason": "Smoke test balance adjustment",
"payload": {"current_balance": 100},
},
)
assert approval_response.status_code == 200
ticket_id = approval_response.json()["ticket_id"]
pending_response = client.patch(
f"/api/v1/business/fund-accounts/{record_id}",
headers=headers,
json={
"actor": "spoofed-user",
"approval_ticket_id": ticket_id,
"data": {"current_balance": 100},
},
)
assert pending_response.status_code == 403
approve_response = client.post(
f"/api/v1/approvals/{ticket_id}/approve",
headers=approval_headers,
json={"approver": "spoofed-manager", "comment": "ok"},
)
assert approve_response.status_code == 200
assert approve_response.json()["status"] == "approved"
assert approve_response.json()["approver"] == "approval-manager"
mismatch_response = client.patch(
f"/api/v1/business/fund-accounts/{record_id}",
headers=headers,
json={
"actor": "spoofed-user",
"approval_ticket_id": ticket_id,
"data": {"current_balance": 101},
},
)
assert mismatch_response.status_code == 403
assert create_response.status_code == 405
update_response = client.patch(
f"/api/v1/business/fund-accounts/{record_id}",
"/api/v1/business/projects/1",
headers=headers,
json={
"actor": "spoofed-user",
"approval_ticket_id": ticket_id,
"data": {"current_balance": 100},
"data": {
"name": "Blocked update",
},
},
)
assert update_response.status_code == 200
assert update_response.json()["data"]["current_balance"] == 100.0
reuse_update_response = client.patch(
f"/api/v1/business/fund-accounts/{record_id}",
headers=headers,
json={
"actor": "spoofed-user",
"approval_ticket_id": ticket_id,
"data": {"current_balance": 100},
},
)
assert reuse_update_response.status_code == 403
assert update_response.status_code == 405
def test_feishu_approval_card_action_approves_ticket() -> None:
def test_approval_and_feishu_approval_card_routes_are_removed() -> None:
approval_response = client.post(
"/api/v1/approvals",
headers=headers,
@@ -690,8 +449,7 @@ def test_feishu_approval_card_action_approves_ticket() -> None:
"payload": {"current_balance": 300},
},
)
assert approval_response.status_code == 200
ticket_id = approval_response.json()["ticket_id"]
assert approval_response.status_code == 404
callback_response = client.post(
"/api/v1/integrations/feishu/approval-card-action",
@@ -700,104 +458,14 @@ def test_feishu_approval_card_action_approves_ticket() -> None:
"operator": {"operator_id": {"open_id": "ou_card_approver"}},
"action": {
"value": {
"ticket_id": ticket_id,
"ticket_id": "APR-DISABLED",
"decision": "approve",
"comment": "approved from card",
}
},
},
)
assert callback_response.status_code == 200
assert callback_response.json()["result"]["status"] == "approved"
assert callback_response.json()["result"]["approver"] == "ou_card_approver"
duplicate_response = client.post(
"/api/v1/integrations/feishu/approval-card-action",
json={
"token": "test-feishu-token",
"operator": {"operator_id": {"open_id": "ou_card_approver"}},
"action": {
"value": {
"ticket_id": ticket_id,
"decision": "approve",
"comment": "approved from card",
}
},
},
)
assert duplicate_response.status_code == 200
assert duplicate_response.json()["duplicate"] is True
assert duplicate_response.json()["result"]["status"] == "approved"
def test_feishu_approval_card_action_requires_approver_allowlist(monkeypatch) -> None:
monkeypatch.setenv("FEISHU_APPROVAL_APPROVER_IDS", "")
get_settings.cache_clear()
try:
approval_response = client.post(
"/api/v1/approvals",
headers=headers,
json={
"domain": "fund-accounts",
"record_id": "feishu-card-missing-allowlist",
"action": "update:fund-accounts",
"reason": "Card action missing allowlist test",
"payload": {"current_balance": 301},
},
)
assert approval_response.status_code == 200
ticket_id = approval_response.json()["ticket_id"]
callback_response = client.post(
"/api/v1/integrations/feishu/approval-card-action",
json={
"token": "test-feishu-token",
"operator": {"operator_id": {"open_id": "ou_card_approver"}},
"action": {
"value": {
"ticket_id": ticket_id,
"decision": "approve",
}
},
},
)
assert callback_response.status_code == 503
assert callback_response.json()["detail"] == FEISHU_APPROVAL_APPROVER_IDS_REQUIRED
finally:
monkeypatch.setenv("FEISHU_APPROVAL_APPROVER_IDS", "ou_card_approver")
get_settings.cache_clear()
def test_feishu_approval_card_action_rejects_unlisted_approver() -> None:
approval_response = client.post(
"/api/v1/approvals",
headers=headers,
json={
"domain": "fund-accounts",
"record_id": "feishu-card-unlisted-approver",
"action": "update:fund-accounts",
"reason": "Card action allowlist test",
"payload": {"current_balance": 302},
},
)
assert approval_response.status_code == 200
ticket_id = approval_response.json()["ticket_id"]
callback_response = client.post(
"/api/v1/integrations/feishu/approval-card-action",
json={
"token": "test-feishu-token",
"operator": {"operator_id": {"open_id": "ou_not_allowed"}},
"action": {
"value": {
"ticket_id": ticket_id,
"decision": "approve",
}
},
},
)
assert callback_response.status_code == 403
assert callback_response.json()["detail"] == FEISHU_APPROVER_NOT_ALLOWED
assert callback_response.status_code == 404
def test_new_ledgers_reports_and_risk_events() -> None:
@@ -843,23 +511,21 @@ def test_new_ledgers_reports_and_risk_events() -> None:
json={"report_type": ReportType.DAILY, "reporter": "pytest", "actor": "pytest"},
)
assert report_response.status_code == 200
assert report_response.json()["data"]["report_type"] == ReportType.DAILY
assert report_response.json()["data"] is None
assert report_response.json()["report"]["report_type"] == ReportType.DAILY
risk_response = client.post(
"/api/v1/risks/events/generate?actor=pytest",
headers=headers,
)
assert risk_response.status_code == 200
assert risk_response.json()["created"] >= 1
assert risk_response.status_code == 405
enqueue_response = client.post("/api/v1/risks/events/enqueue", headers=headers)
assert enqueue_response.status_code == 200
assert enqueue_response.json()["queued"] is False
assert "result" in enqueue_response.json()
assert enqueue_response.status_code == 405
events_response = client.get("/api/v1/risks/events?status=open", headers=headers)
assert events_response.status_code == 200
assert any(item["risk_type"] == "overdue_task" for item in events_response.json()["items"])
overdue_response = client.get("/api/v1/risks/overdue-tasks", headers=headers)
assert overdue_response.status_code == 200
assert any(item["code"] == "TASK-RISK-001" for item in overdue_response.json()["items"])
def test_project_lifecycle_report_summarizes_progress_cost_and_risk() -> None:
@@ -1027,7 +693,7 @@ def test_work_report_counts_pending_approval_backlog_outside_period() -> None:
assert metrics["expenses_pending"] == 1
def test_legacy_task_sync_creates_and_updates_internal_tasks(monkeypatch) -> None:
def test_legacy_task_read_query_allowed_but_sync_disabled(monkeypatch) -> None:
rows = [
{
"id": 9001,
@@ -1047,6 +713,15 @@ def test_legacy_task_sync_creates_and_updates_internal_tasks(monkeypatch) -> Non
fake_execute_allowed_query,
)
query_response = client.post(
"/api/v1/integrations/mysql/query",
headers=headers,
json={"query_name": "legacy_tasks"},
)
assert query_response.status_code == 200
assert query_response.json()["row_count"] == 1
assert query_response.json()["rows"][0]["task_name"] == "Legacy task one"
response = client.post(
"/api/v1/integrations/mysql/tasks/sync",
headers=headers,
@@ -1055,31 +730,10 @@ def test_legacy_task_sync_creates_and_updates_internal_tasks(monkeypatch) -> Non
"field_map": {"title": "task_name"},
},
)
assert response.status_code == 200
assert response.json()["created"] == 1
assert response.json()["items"][0]["task"]["external_id"] == "9001"
rows[0]["task_name"] = "Legacy task one updated"
second_response = client.post(
"/api/v1/integrations/mysql/tasks/sync",
headers=headers,
json={
"dry_run": False,
"field_map": {"title": "task_name"},
},
)
assert second_response.status_code == 200
assert second_response.json()["updated"] == 1
tasks_response = client.get("/api/v1/business/tasks", headers=headers)
assert tasks_response.status_code == 200
item = next(
item for item in tasks_response.json()["items"] if item["external_id"] == "9001"
)
assert item["title"] == "Legacy task one updated"
assert response.status_code == 405
def test_risk_event_workflow_records_actions() -> None:
def test_risk_event_action_routes_are_disabled_in_read_only_mode() -> None:
create_response = create_business_record(
"risk-events",
{
@@ -1100,57 +754,21 @@ def test_risk_event_workflow_records_actions() -> None:
headers=headers,
json={"assigned_to": "risk-owner", "comment": "please handle"},
)
assert assign_response.status_code == 200
assert assign_response.json()["risk_event"]["assigned_to"] == "risk-owner"
assert assign_response.status_code == 405
comment_response = client.post(
f"/api/v1/risks/events/{event_id}/comment",
headers=headers,
json={"comment": "working on it", "payload": {"step": 1}},
)
assert comment_response.status_code == 200
assert comment_response.status_code == 405
resolve_response = client.post(
f"/api/v1/risks/events/{event_id}/resolve",
headers=headers,
json={"comment": "resolved"},
)
assert resolve_response.status_code == 200
assert resolve_response.json()["risk_event"]["status"] == "resolved"
blocked_close_response = client.post(
f"/api/v1/risks/events/{event_id}/close",
headers=headers,
json={
"closed_reason": "verified",
"review_summary": "handled",
},
)
assert blocked_close_response.status_code == 409
close_ticket_response = client.post(
"/api/v1/approvals",
headers=headers,
json={
"domain": "risk-events",
"record_id": str(event_id),
"action": "update:risk-events",
"reason": "Close risk event",
"payload": {
"status": "closed",
"closed_reason": "verified",
"review_summary": "handled",
},
},
)
assert close_ticket_response.status_code == 200
close_ticket_id = close_ticket_response.json()["ticket_id"]
approve_close_response = client.post(
f"/api/v1/approvals/{close_ticket_id}/approve",
headers=approval_headers,
json={"comment": "risk close approved"},
)
assert approve_close_response.status_code == 200
assert resolve_response.status_code == 405
close_response = client.post(
f"/api/v1/risks/events/{event_id}/close",
@@ -1158,54 +776,23 @@ def test_risk_event_workflow_records_actions() -> None:
json={
"closed_reason": "verified",
"review_summary": "handled",
"approval_ticket_id": close_ticket_id,
},
)
assert close_response.status_code == 200
assert close_response.json()["risk_event"]["status"] == "closed"
assert close_response.json()["risk_event"]["closed_reason"] == "verified"
blocked_reopen_response = client.post(
f"/api/v1/risks/events/{event_id}/reopen",
headers=headers,
json={"comment": "recheck"},
)
assert blocked_reopen_response.status_code == 409
reopen_ticket_response = client.post(
"/api/v1/approvals",
headers=headers,
json={
"domain": "risk-events",
"record_id": str(event_id),
"action": "update:risk-events",
"reason": "Reopen risk event",
"payload": {"status": "open", "comment": "recheck"},
},
)
assert reopen_ticket_response.status_code == 200
reopen_ticket_id = reopen_ticket_response.json()["ticket_id"]
approve_reopen_response = client.post(
f"/api/v1/approvals/{reopen_ticket_id}/approve",
headers=approval_headers,
json={"comment": "risk reopen approved"},
)
assert approve_reopen_response.status_code == 200
assert close_response.status_code == 405
reopen_response = client.post(
f"/api/v1/risks/events/{event_id}/reopen",
headers=headers,
json={"comment": "recheck", "approval_ticket_id": reopen_ticket_id},
json={"comment": "recheck"},
)
assert reopen_response.status_code == 200
assert reopen_response.json()["risk_event"]["status"] == "open"
assert reopen_response.status_code == 405
actions_response = client.get(
f"/api/v1/risks/events/{event_id}/actions",
headers=headers,
)
assert actions_response.status_code == 200
assert len(actions_response.json()["items"]) >= 5
assert actions_response.json()["items"] == []
def test_report_push_failure_is_recorded() -> None: