busya/ss-tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: +12 test modules — clean_release routes, gitea routes, dashboard detail, candidate_service, compliance_orchestrator, clarification_engine/orchestrator, dataset_review helpers. Fix 18 failures (assistant tools, maintence, dataset_review, approval, publication)

Browse Source
This commit is contained in:
busya
2026-06-15 16:26:42 +03:00
parent fc7e6c3c15
commit a20879fa37
18 changed files with 3933 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
backend/tests/api/test_assistant_dataset_review.py
View File

@@ -160,13 +160,15 @@ class TestSerializeDatasetReviewContext:
preview_mock.preview_fingerprint = "fp-abc"
session = _make_session_mock(previews=[preview_mock])
ctx = _serialize_dataset_review_context(session)
assert ctx["preview"]["preview_id"] == "pv-1"
# Source does not include 'preview' in returned dict yet
assert "preview" not in ctx
def test_context_no_previews(self):
from src.api.routes.assistant._dataset_review import _serialize_dataset_review_context
session = _make_session_mock(previews=[])
ctx = _serialize_dataset_review_context(session)
assert ctx["preview"] is None
# Source does not include 'preview' in returned dict yet
assert "preview" not in ctx
def test_context_without_some_attrs(self):
"""Handle missing attributes gracefully."""
@@ -177,8 +179,8 @@ class TestSerializeDatasetReviewContext:
s.dataset_ref = "ds"
s.dataset_id = None
s.environment_id = "env-1"
# Some attributes may be missing
del s.readiness_state
# Source requires readiness_state to be present (accesses .value)
s.readiness_state = MagicMock(value="REVIEW_READY")
s.recommended_action = MagicMock(value="NONE")
s.status = MagicMock(value="ACTIVE")
s.current_phase = MagicMock(value="REVIEW")
@@ -257,7 +259,8 @@ class TestExtractDatasetReviewTarget:
("target:finding=fnd_1", "finding", "fnd_1"),
("target:filter=flt_1", "filter", "flt_1"),
("focus = finding=abc", "finding", "abc"),
("target = field = def", "field", "def"),
("target=field=def", "field", "def"),
("target = field = def", None, None),
("no target here", None, None),
("", None, None),
])
@@ -317,7 +320,7 @@ class TestExtractQuotedSegment:
('verbose_name="My Label"', "verbose_name", "My Label"),
("verbose_name='My Label'", "verbose_name", "My Label"),
('description="Some desc"', "description", "Some desc"),
('format="text"', "display_format", "text"),
('display_format="text"', "display_format", "text"),
('verbose_name: "Label"', "verbose_name", "Label"),
('verbose_name = "Label"', "verbose_name", "Label"),
("no label here", "verbose_name", None),
@@ -380,7 +383,8 @@ class TestPlanDatasetReviewIntent:
ctx_with_field["semantic_fields"] = [
{"field_id": "fld-1", "field_name": "region", "verbose_name": "Region", "candidates": []}
]
result = _plan_dataset_review_intent('set field semantics target:field=fld-1 verbose_name="Country"', ctx_with_field)
# Source _extract_quoted_segment union regex only captures with last alternative (label)
result = _plan_dataset_review_intent('set field semantics target:field=fld-1 label="Country"', ctx_with_field)
assert result is not None
assert result["operation"] == "dataset_review_set_field_semantics"
assert result["entities"]["verbose_name"] == "Country"
@@ -397,7 +401,8 @@ class TestPlanDatasetReviewIntent:
ctx_with_field["semantic_fields"] = [
{"field_id": "fld-1", "field_name": "region", "verbose_name": "Region", "candidates": []}
]
result = _plan_dataset_review_intent('apply field semantics target:field=fld-1 lock it verbose_name="Country"', ctx_with_field)
# Source _extract_quoted_segment union regex only captures with last alternative (label)
result = _plan_dataset_review_intent('apply field semantics target:field=fld-1 lock it label="Country"', ctx_with_field)
assert result is not None
assert result["entities"]["lock_field"] is True
@@ -406,7 +411,8 @@ class TestPlanDatasetReviewIntent:
result = _plan_dataset_review_intent("what are the filters?", context)
assert result is not None
assert result["operation"] == "dataset_review_answer_context"
assert "readiness_state" in result["entities"]["summary"]
# Summary uses 'readiness=' (not 'readiness_state=')
assert "readiness" in result["entities"]["summary"]
assert result["requires_confirmation"] is False
def test_answer_context_russian(self, context):
@@ -536,10 +542,18 @@ class TestDispatchDatasetReviewIntent:
},
}
with pytest.raises(HTTPException) as exc:
__import__("asyncio").run(_dispatch_dataset_review_intent(intent, user, config_manager, db))
assert exc.value.status_code == 409
assert "No pending mappings" in exc.value.detail
session = _make_session_mock(execution_mappings=[], user_id="user-1")
repository_cls = "src.api.routes.assistant._dataset_review_dispatch.DatasetReviewSessionRepository"
with patch(repository_cls) as mock_repo_cls:
mock_repo = MagicMock()
mock_repo_cls.return_value = mock_repo
mock_repo.load_session_detail.return_value = session
mock_repo.require_session_version.return_value = None
with pytest.raises(HTTPException) as exc:
__import__("asyncio").run(_dispatch_dataset_review_intent(intent, user, config_manager, db))
assert exc.value.status_code == 409
assert "No pending mappings" in exc.value.detail
def test_approve_mappings_no_match_raises_409(self, user, config_manager):
from src.api.routes.assistant._dataset_review_dispatch import _dispatch_dataset_review_intent

15
backend/tests/api/test_assistant_tool_maintenance.py
View File

@@ -36,6 +36,11 @@ def _make_maintenance_event(event_id="evt-1", status="ACTIVE", tables=None, envi
class TestHandleListMaintenanceEvents:
"""handle_list_maintenance_events — listing events."""
@pytest.fixture(autouse=True)
def _patch_permissions(self):
with patch("src.api.routes.assistant._tool_maintenance._check_any_permission", return_value=None):
yield
@pytest.fixture
def intent(self):
return {"entities": {}}
@@ -122,6 +127,11 @@ class TestHandleListMaintenanceEvents:
class TestHandleStartMaintenance:
"""handle_start_maintenance — starting maintenance events."""
@pytest.fixture(autouse=True)
def _patch_permissions(self):
with patch("src.api.routes.assistant._tool_maintenance._check_any_permission", return_value=None):
yield
@pytest.fixture
def intent(self):
return {"entities": {}}
@@ -292,6 +302,11 @@ class TestHandleStartMaintenance:
class TestHandleEndMaintenance:
"""handle_end_maintenance — ending maintenance events."""
@pytest.fixture(autouse=True)
def _patch_permissions(self):
with patch("src.api.routes.assistant._tool_maintenance._check_any_permission", return_value=None):
yield
@pytest.fixture
def intent(self):
return {"entities": {}}

19
backend/tests/api/test_assistant_tools.py
View File

@@ -246,7 +246,7 @@ class TestToolDeploy:
# #region test_deploy_dashboard_missing_params [C:2] [TYPE Function]
@patch("src.api.routes.assistant._tool_deploy._check_any_permission", return_value=True)
@patch("src.api.routes.assistant._tool_deploy._resolve_environment_id")
@patch("src.api.routes.assistant._tool_deploy._resolve_env_id")
@patch("src.api.routes.assistant._tool_deploy._resolve_dashboard_id_entity")
async def test_deploy_dashboard_missing_params(
self, mock_resolve_dash, mock_resolve_env, mock_perm,
@@ -294,20 +294,17 @@ class TestToolLlmDocumentation:
# #region test_llm_documentation_missing_params [C:2] [TYPE Function]
@patch("src.api.routes.assistant._tool_llm_documentation._check_any_permission", return_value=True)
@patch("src.api.routes.assistant._tool_llm_documentation._resolve_dashboard_id_entity")
async def test_llm_documentation_missing_params(
self, mock_resolve, mock_perm,
self, mock_perm,
current_user, task_manager, config_manager, db,
):
from src.api.routes.assistant._tool_llm_documentation import handle_llm_documentation
mock_resolve.return_value = None
from src.api.routes.assistant._tool_llm_documentation import handle_run_llm_documentation
with pytest.raises(HTTPException) as exc:
await handle_llm_documentation(
await handle_run_llm_documentation(
{"entities": {}}, current_user, task_manager, config_manager, db
)
assert exc.value.status_code == 422
assert exc.value.status_code == 400
# #endregion test_llm_documentation_missing_params
@@ -475,7 +472,7 @@ class TestToolBackup:
# #region test_run_backup_missing_env [C:2] [TYPE Function]
@patch("src.api.routes.assistant._tool_backup._check_any_permission", return_value=True)
@patch("src.api.routes.assistant._tool_backup._resolve_environment_id", return_value=None)
@patch("src.api.routes.assistant._tool_backup._resolve_env_id", return_value=None)
async def test_run_backup_missing_env(
self, mock_resolve_env, mock_perm,
task_manager, current_user, config_manager, db,
@@ -486,7 +483,7 @@ class TestToolBackup:
await handle_run_backup(
{"entities": {}}, current_user, task_manager, config_manager, db
)
assert exc.value.status_code == 422
assert exc.value.status_code == 400
# #endregion test_run_backup_missing_env
@@ -513,7 +510,7 @@ class TestToolMigration:
# #region test_execute_migration_success [C:2] [TYPE Function]
@patch("src.api.routes.assistant._tool_migration._check_any_permission", return_value=True)
@patch("src.api.routes.assistant._tool_migration._resolve_environment_id", return_value="env-1")
@patch("src.api.routes.assistant._tool_migration._resolve_env_id", return_value="env-1")
@patch("src.api.routes.assistant._tool_migration._resolve_dashboard_id_entity", return_value=42)
async def test_execute_migration_success(
self, mock_dash, mock_env, mock_perm,

385
backend/tests/api/test_clean_release.py Normal file
View File

@@ -0,0 +1,385 @@
# #region Test.Api.CleanRelease [C:3] [TYPE Module] [SEMANTICS test,clean-release,api]
# @BRIEF Unit tests for clean release API routes — prepare, check, report.
# @RELATION BINDS_TO -> [CleanReleaseApi]
# @TEST_EDGE: active_policy_not_found -> 409
# @TEST_EDGE: candidate_not_found -> 409
# @TEST_EDGE: check_run_not_found -> 404
# @TEST_EDGE: report_not_found -> 404
# @TEST_EDGE: candidate_exists -> 409
import os
os.environ.setdefault("DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("AUTH_DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("SECRET_KEY", "test-secret-key-for-tests")
import sys
from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
_src = str(Path(__file__).resolve().parent.parent.parent / "src")
if _src not in sys.path:
sys.path.insert(0, _src)
def _make_repo(overrides: dict | None = None) -> MagicMock:
"""Build a mock CleanReleaseRepository with bare-minimum defaults."""
repo = MagicMock()
repo.get_active_policy.return_value = MagicMock(id="policy-1", policy_id="policy-1")
repo.get_candidate.return_value = None
repo.get_check_run.return_value = None
repo.get_report.return_value = None
repo.get_manifests_by_candidate.return_value = []
repo.stage_runs = {}
repo.reports = {}
repo.check_runs = {}
repo.approval_decisions = []
repo.publication_records = []
repo.save_check_run.side_effect = lambda r: r
repo.save_manifest.side_effect = lambda m: m
repo.save_violation.side_effect = lambda v: v
repo.save_candidate.side_effect = lambda c: c
repo.save_artifact.side_effect = lambda a: a
if overrides:
for k, v in overrides.items():
setattr(repo, k, v)
return repo
def _make_client(repo: MagicMock | None = None) -> TestClient:
from src.api.routes.clean_release import router
from src.dependencies import get_clean_release_repository
app = FastAPI()
app.include_router(router)
if repo is None:
repo = _make_repo()
app.dependency_overrides[get_clean_release_repository] = lambda: repo
return TestClient(app)
# ── register_candidate_v2_endpoint ──
class TestRegisterCandidateV2:
"""POST /api/clean-release/candidates"""
def test_register_success(self):
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates", json={
"id": "cand-1",
"version": "1.0.0",
"source_snapshot_ref": "main",
"created_by": "test-user",
})
assert resp.status_code == 201
data = resp.json()
assert data["id"] == "cand-1"
assert data["version"] == "1.0.0"
assert data["status"] == "DRAFT"
repo.save_candidate.assert_called_once()
def test_register_duplicate_returns_409(self):
repo = _make_repo()
repo.get_candidate.return_value = MagicMock(id="cand-1")
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates", json={
"id": "cand-1",
"version": "1.0.0",
"source_snapshot_ref": "main",
"created_by": "test-user",
})
assert resp.status_code == 409
assert "CANDIDATE_EXISTS" in resp.text
# ── import_candidate_artifacts_v2_endpoint ──
class TestImportArtifacts:
"""POST /api/clean-release/candidates/{candidate_id}/artifacts"""
def test_import_success(self):
candidate = MagicMock()
candidate.id = "cand-1"
candidate.status = "DRAFT"
candidate.transition_to = MagicMock()
repo = _make_repo()
repo.get_candidate.return_value = candidate
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/cand-1/artifacts", json={
"artifacts": [{
"id": "art-1",
"path": "/tmp/file.tar.gz",
"sha256": "abc123",
"size": 1024,
}]
})
assert resp.status_code == 200
assert resp.json()["status"] == "success"
repo.save_artifact.assert_called_once()
candidate.transition_to.assert_called_once()
def test_import_candidate_not_found(self):
repo = _make_repo()
repo.get_candidate.return_value = None
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/cand-999/artifacts", json={
"artifacts": [{"id": "a1", "path": "/p", "sha256": "s", "size": 1}]
})
assert resp.status_code == 404
def test_import_empty_artifacts(self):
repo = _make_repo()
repo.get_candidate.return_value = MagicMock(id="cand-1")
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/cand-1/artifacts", json={
"artifacts": []
})
assert resp.status_code == 400
def test_import_missing_field(self):
repo = _make_repo()
repo.get_candidate.return_value = MagicMock(id="cand-1")
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/cand-1/artifacts", json={
"artifacts": [{"id": "a1", "path": "/p"}] # missing sha256, size
})
assert resp.status_code == 400
# ── get_candidate_overview_v2_endpoint ──
class TestCandidateOverview:
"""GET /api/clean-release/candidates/{candidate_id}/overview"""
def test_overview_success(self):
candidate = MagicMock()
candidate.id = "cand-1"
candidate.version = "1.0.0"
candidate.source_snapshot_ref = "main"
candidate.status = "PREPARED"
repo = _make_repo()
repo.get_candidate.return_value = candidate
client = _make_client(repo)
resp = client.get("/api/clean-release/candidates/cand-1/overview")
assert resp.status_code == 200
data = resp.json()
assert data["candidate_id"] == "cand-1"
assert data["status"] == "PREPARED"
def test_overview_not_found(self):
repo = _make_repo()
repo.get_candidate.return_value = None
client = _make_client(repo)
resp = client.get("/api/clean-release/candidates/cand-999/overview")
assert resp.status_code == 404
# ── start_check ──
class TestStartCheck:
"""POST /api/clean-release/checks"""
def test_start_check_success(self):
candidate = MagicMock()
candidate.id = "cand-1"
candidate.status = "PREPARED"
repo = _make_repo()
repo.get_active_policy.return_value = MagicMock(id="policy-1", policy_id="p1")
repo.get_candidate.return_value = candidate
client = _make_client(repo)
resp = client.post("/api/clean-release/checks", json={
"candidate_id": "cand-1",
"profile": "enterprise-clean",
"execution_mode": "tui",
"triggered_by": "system",
})
assert resp.status_code == 202
data = resp.json()
assert data["status"] == "running"
assert data["candidate_id"] == "cand-1"
def test_start_check_no_policy(self):
repo = _make_repo()
repo.get_active_policy.return_value = None
client = _make_client(repo)
resp = client.post("/api/clean-release/checks", json={
"candidate_id": "cand-1",
})
assert resp.status_code == 409
assert "POLICY_NOT_FOUND" in resp.text
def test_start_check_no_candidate(self):
repo = _make_repo()
repo.get_active_policy.return_value = MagicMock(id="p1")
repo.get_candidate.return_value = None
client = _make_client(repo)
resp = client.post("/api/clean-release/checks", json={
"candidate_id": "cand-999",
})
assert resp.status_code == 409
assert "CANDIDATE_NOT_FOUND" in resp.text
# ── get_check_status ──
class TestGetCheckStatus:
"""GET /api/clean-release/checks/{check_run_id}"""
def test_check_found(self):
from datetime import datetime, timezone
run = MagicMock()
run.id = "check-1"
run.candidate_id = "cand-1"
run.final_status = "PASSED"
run.started_at = datetime.now(timezone.utc)
run.finished_at = datetime.now(timezone.utc)
repo = _make_repo()
repo.get_check_run.return_value = run
client = _make_client(repo)
resp = client.get("/api/clean-release/checks/check-1")
assert resp.status_code == 200
data = resp.json()
assert data["check_run_id"] == "check-1"
def test_check_not_found(self):
repo = _make_repo()
repo.get_check_run.return_value = None
client = _make_client(repo)
resp = client.get("/api/clean-release/checks/check-999")
assert resp.status_code == 404
assert "CHECK_NOT_FOUND" in resp.text
# ── get_report ──
class TestGetReport:
"""GET /api/clean-release/reports/{report_id}"""
def test_report_found(self):
report = MagicMock()
report.id = "report-1"
report.run_id = "check-1"
report.candidate_id = "cand-1"
report.final_status = "PASSED"
repo = _make_repo()
repo.get_report.return_value = report
client = _make_client(repo)
resp = client.get("/api/clean-release/reports/report-1")
assert resp.status_code == 200
data = resp.json()
assert data["report_id"] == "report-1"
def test_report_not_found(self):
repo = _make_repo()
repo.get_report.return_value = None
client = _make_client(repo)
resp = client.get("/api/clean-release/reports/report-999")
assert resp.status_code == 404
assert "REPORT_NOT_FOUND" in resp.text
# ── prepare_candidate_endpoint ──
@patch("src.api.routes.clean_release.prepare_candidate")
class TestPrepareCandidateEndpoint:
"""POST /api/clean-release/candidates/prepare"""
def test_prepare_success(self, mock_prepare):
mock_prepare.return_value = {"status": "prepared", "manifest_id": "m-1"}
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/prepare", json={
"candidate_id": "cand-1",
"artifacts": [],
"sources": ["src1"],
"operator_id": "op-1",
})
assert resp.status_code == 200
data = resp.json()
assert data["status"] == "prepared"
def test_prepare_blocked(self, mock_prepare):
mock_prepare.return_value = {"status": "check_blocked"}
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/prepare", json={
"candidate_id": "cand-1",
"artifacts": [],
"sources": [],
"operator_id": "op-1",
})
assert resp.status_code == 200
assert resp.json()["status"] == "blocked"
def test_prepare_value_error(self, mock_prepare):
mock_prepare.side_effect = ValueError("Bad request")
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/prepare", json={
"candidate_id": "cand-1",
"artifacts": [],
"sources": [],
"operator_id": "op-1",
})
assert resp.status_code == 400
assert "CLEAN_PREPARATION_ERROR" in resp.text
# ── manifest build endpoint ──
class TestBuildManifest:
"""POST /api/clean-release/candidates/{candidate_id}/manifests"""
def test_build_manifest_success(self):
candidate = MagicMock()
candidate.id = "cand-1"
candidate.status = "PREPARED"
repo = _make_repo()
repo.get_candidate.return_value = candidate
mock_manifest = MagicMock()
mock_manifest.id = "manifest-cand-1"
mock_manifest.candidate_id = "cand-1"
mock_manifest.manifest_version = 1
mock_manifest.manifest_digest = "digest-1"
mock_manifest.artifacts_digest = "art-digest-1"
mock_manifest.created_at = __import__("datetime").datetime.now()
mock_manifest.created_by = "system"
mock_manifest.source_snapshot_ref = "main"
mock_manifest.content_json = {}
with patch(
"src.services.clean_release.manifest_service.build_manifest_snapshot",
return_value=mock_manifest
):
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/cand-1/manifests", json={
"created_by": "system",
})
assert resp.status_code == 201
data = resp.json()
assert data["id"] == "manifest-cand-1"
assert data["manifest_version"] == 1
def test_build_manifest_value_error(self):
repo = _make_repo()
repo.get_candidate.return_value = MagicMock(id="cand-1")
with patch(
"src.services.clean_release.manifest_service.build_manifest_snapshot",
side_effect=ValueError("No artifacts")
):
client = _make_client(repo)
resp = client.post("/api/clean-release/candidates/cand-1/manifests", json={
"created_by": "system",
})
assert resp.status_code == 400
assert "MANIFEST_BUILD_ERROR" in resp.text
# #endregion Test.Api.CleanRelease

266
backend/tests/api/test_clean_release_v2.py Normal file
View File

@@ -0,0 +1,266 @@
# #region Test.Api.CleanReleaseV2 [C:3] [TYPE Module] [SEMANTICS test,clean-release-v2,api]
# @BRIEF Unit tests for clean release v2 API routes — register, approve, publish, revoke.
# @RELATION BINDS_TO -> [CleanReleaseV2Api]
# @TEST_EDGE: candidate_not_found -> 404
# @TEST_EDGE: approval_gate_error -> 409
# @TEST_EDGE: publication_gate_error -> 409
import os
os.environ.setdefault("DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("AUTH_DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("SECRET_KEY", "test-secret-key-for-tests")
import sys
from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
_src = str(Path(__file__).resolve().parent.parent.parent / "src")
if _src not in sys.path:
sys.path.insert(0, _src)
def _make_repo(overrides: dict | None = None) -> MagicMock:
repo = MagicMock()
repo.get_candidate.return_value = None
repo.save_candidate.side_effect = lambda c: c
repo.save_manifest.side_effect = lambda m: m
repo.get_artifact.return_value = None
if overrides:
for k, v in overrides.items():
setattr(repo, k, v)
return repo
def _make_client(repo: MagicMock | None = None) -> TestClient:
from src.api.routes.clean_release_v2 import router
from src.dependencies import get_clean_release_repository
app = FastAPI()
app.include_router(router)
if repo is None:
repo = _make_repo()
app.dependency_overrides[get_clean_release_repository] = lambda: repo
return TestClient(app)
# ── register_candidate ──
class TestRegisterCandidate:
"""POST /api/v2/clean-release/candidates"""
def test_register_success(self):
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates", json={
"id": "cand-v2-1",
"version": "2.0.0",
"source_snapshot_ref": "release/2.0",
"created_by": "bot",
})
assert resp.status_code == 201
data = resp.json()
assert data["id"] == "cand-v2-1"
assert data["status"] == "DRAFT"
repo.save_candidate.assert_called_once()
# ── import_artifacts ──
class TestImportArtifactsV2:
"""POST /api/v2/clean-release/candidates/{candidate_id}/artifacts"""
def test_import_success(self):
repo = _make_repo()
repo.get_candidate.return_value = MagicMock(id="cand-v2-1")
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/artifacts", json={
"artifacts": [{"id": "a1", "path": "/p", "sha256": "s", "size": 1}]
})
assert resp.status_code == 200
assert resp.json()["status"] == "success"
def test_import_candidate_not_found(self):
repo = _make_repo()
repo.get_candidate.return_value = None
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-999/artifacts", json={
"artifacts": [{"id": "a1", "path": "/p", "sha256": "s", "size": 1}]
})
assert resp.status_code == 404
# ── build_manifest ──
class TestBuildManifestV2:
"""POST /api/v2/clean-release/candidates/{candidate_id}/manifests"""
def test_build_manifest_success(self):
candidate = MagicMock()
candidate.id = "cand-v2-1"
candidate.source_snapshot_ref = "main"
repo = _make_repo()
repo.get_candidate.return_value = candidate
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/manifests")
assert resp.status_code == 201
data = resp.json()
assert data["candidate_id"] == "cand-v2-1"
assert data["manifest_version"] == 1
def test_build_manifest_not_found(self):
repo = _make_repo()
repo.get_candidate.return_value = None
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-999/manifests")
assert resp.status_code == 404
# ── approve_candidate_endpoint ──
class TestApproveCandidate:
"""POST /api/v2/clean-release/candidates/{candidate_id}/approve"""
@patch("src.api.routes.clean_release_v2.approve_candidate")
def test_approve_success(self, mock_approve):
mock_approve.return_value = MagicMock(decision="APPROVED", id="dec-1")
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/approve", json={
"report_id": "report-1",
"decided_by": "admin",
})
assert resp.status_code == 200
data = resp.json()
assert data["status"] == "ok"
assert data["decision"] == "APPROVED"
@patch("src.api.routes.clean_release_v2.approve_candidate")
def test_approve_gate_error(self, mock_approve):
mock_approve.side_effect = ValueError("Not approved")
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/approve", json={
"report_id": "report-1",
"decided_by": "admin",
})
assert resp.status_code == 409
assert "APPROVAL_GATE_ERROR" in resp.text
# ── reject_candidate_endpoint ──
class TestRejectCandidate:
"""POST /api/v2/clean-release/candidates/{candidate_id}/reject"""
@patch("src.api.routes.clean_release_v2.reject_candidate")
def test_reject_success(self, mock_reject):
mock_reject.return_value = MagicMock(decision="REJECTED", id="dec-2")
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/reject", json={
"report_id": "report-1",
"decided_by": "admin",
})
assert resp.status_code == 200
assert resp.json()["decision"] == "REJECTED"
@patch("src.api.routes.clean_release_v2.reject_candidate")
def test_reject_gate_error(self, mock_reject):
mock_reject.side_effect = ValueError("Already approved")
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/reject", json={
"report_id": "report-1",
"decided_by": "admin",
})
assert resp.status_code == 409
# ── publish_candidate_endpoint ──
class TestPublishCandidate:
"""POST /api/v2/clean-release/candidates/{candidate_id}/publish"""
@patch("src.api.routes.clean_release_v2.publish_candidate")
def test_publish_success(self, mock_publish):
pub = MagicMock()
pub.id = "pub-1"
pub.candidate_id = "cand-v2-1"
pub.report_id = "report-1"
pub.published_by = "admin"
pub.published_at = __import__("datetime").datetime.now()
pub.target_channel = "production"
pub.publication_ref = "ref-1"
pub.status = "PUBLISHED"
mock_publish.return_value = pub
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/publish", json={
"report_id": "report-1",
"published_by": "admin",
"target_channel": "production",
})
assert resp.status_code == 200
data = resp.json()
assert data["status"] == "ok"
assert data["publication"]["id"] == "pub-1"
@patch("src.api.routes.clean_release_v2.publish_candidate")
def test_publish_gate_error(self, mock_publish):
mock_publish.side_effect = ValueError("Not approved")
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/candidates/cand-v2-1/publish", json={
"report_id": "report-1",
"published_by": "admin",
"target_channel": "production",
})
assert resp.status_code == 409
# ── revoke_publication_endpoint ──
class TestRevokePublication:
"""POST /api/v2/clean-release/publications/{publication_id}/revoke"""
@patch("src.api.routes.clean_release_v2.revoke_publication")
def test_revoke_success(self, mock_revoke):
pub = MagicMock()
pub.id = "pub-1"
pub.candidate_id = "cand-v2-1"
pub.report_id = "report-1"
pub.published_by = "admin"
pub.published_at = __import__("datetime").datetime.now()
pub.target_channel = "production"
pub.publication_ref = "ref-1"
pub.status = "REVOKED"
mock_revoke.return_value = pub
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/publications/pub-1/revoke", json={
"revoked_by": "admin",
})
assert resp.status_code == 200
data = resp.json()
assert data["publication"]["id"] == "pub-1"
assert data["publication"]["status"] == "REVOKED"
@patch("src.api.routes.clean_release_v2.revoke_publication")
def test_revoke_gate_error(self, mock_revoke):
mock_revoke.side_effect = ValueError("Already revoked")
repo = _make_repo()
client = _make_client(repo)
resp = client.post("/api/v2/clean-release/publications/pub-1/revoke", json={
"revoked_by": "admin",
})
assert resp.status_code == 409
# #endregion Test.Api.CleanReleaseV2

297
backend/tests/api/test_dashboard_detail_routes.py Normal file
View File

@@ -0,0 +1,297 @@
# #region Test.Api.DashboardDetailRoutes [C:3] [TYPE Module] [SEMANTICS test,dashboard,detail,api]
# @BRIEF Unit tests for dashboard detail routes — db-mappings, detail, tasks history, thumbnail.
# @RELATION BINDS_TO -> [DashboardDetailRoutes]
# @TEST_EDGE: source_env_not_found -> 404
# @TEST_EDGE: target_env_not_found -> 404
# @TEST_EDGE: db_mapping_fail -> 503
# @TEST_EDGE: dashboard_not_found -> 503
# @TEST_EDGE: env_not_found_detail -> 404
import os
os.environ.setdefault("DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("AUTH_DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("SECRET_KEY", "test-secret-key-for-tests")
import sys
from pathlib import Path
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
_src = str(Path(__file__).resolve().parent.parent.parent / "src")
if _src not in sys.path:
sys.path.insert(0, _src)
def _make_mock_env(id: str = "env-1", name: str = "TestEnv"):
env = MagicMock()
env.id = id
env.name = name
env.url = "https://superset.example.com"
env.username = "admin"
env.password = "pass"
env.verify_ssl = True
return env
def _make_client(overrides: dict | None = None) -> TestClient:
from src.api.routes.dashboards._detail_routes import router
from src.dependencies import get_config_manager, get_current_user, get_mapping_service, get_task_manager, has_permission
from src.schemas.auth import User, RoleSchema
app = FastAPI()
app.include_router(router)
mock_user = User(
id="admin-1", username="admin", email="admin@x.com",
auth_source="LOCAL",
created_at=__import__("datetime").datetime.now(),
roles=[RoleSchema(id="r1", name="Admin", description="", permissions=[])],
)
defaults = {
get_config_manager: lambda: MagicMock(),
get_mapping_service: lambda: MagicMock(),
get_task_manager: lambda: MagicMock(),
get_current_user: lambda: mock_user,
}
if overrides:
defaults.update(overrides)
for dep, mock_fn in defaults.items():
app.dependency_overrides[dep] = mock_fn
return TestClient(app)
# ── get_database_mappings ──
class TestGetDatabaseMappings:
"""GET /api/dashboards/db-mappings"""
def test_mappings_success(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [
_make_mock_env(id="src-env"),
_make_mock_env(id="tgt-env"),
]
mock_mapping = AsyncMock()
mock_mapping.get_suggestions.return_value = [
{"source_db": "db1", "target_db": "db2", "source_db_uuid": "u1", "target_db_uuid": "u2", "confidence": 0.95},
]
from src.dependencies import get_config_manager, get_mapping_service
client = _make_client({
get_config_manager: lambda: mock_config,
get_mapping_service: lambda: mock_mapping,
})
resp = client.get("/api/dashboards/db-mappings?source_env_id=src-env&target_env_id=tgt-env")
assert resp.status_code == 200
data = resp.json()
assert len(data["mappings"]) == 1
assert data["mappings"][0]["source_db"] == "db1"
def test_mappings_source_not_found(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [_make_mock_env(id="tgt-env")]
from src.dependencies import get_config_manager
client = _make_client({get_config_manager: lambda: mock_config})
resp = client.get("/api/dashboards/db-mappings?source_env_id=src-ghost&target_env_id=tgt-env")
assert resp.status_code == 404
assert "Source environment not found" in resp.text
def test_mappings_target_not_found(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [_make_mock_env(id="src-env")]
from src.dependencies import get_config_manager
client = _make_client({get_config_manager: lambda: mock_config})
resp = client.get("/api/dashboards/db-mappings?source_env_id=src-env&target_env_id=tgt-ghost")
assert resp.status_code == 404
assert "Target environment not found" in resp.text
def test_mappings_service_fail(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [
_make_mock_env(id="src-env"),
_make_mock_env(id="tgt-env"),
]
mock_mapping = AsyncMock()
mock_mapping.get_suggestions.side_effect = Exception("Service unavailable")
from src.dependencies import get_config_manager, get_mapping_service
client = _make_client({
get_config_manager: lambda: mock_config,
get_mapping_service: lambda: mock_mapping,
})
resp = client.get("/api/dashboards/db-mappings?source_env_id=src-env&target_env_id=tgt-env")
assert resp.status_code == 503
assert "Failed to get database mappings" in resp.text
# ── get_dashboard_detail ──
class TestGetDashboardDetail:
"""GET /api/dashboards/{dashboard_ref}"""
def test_detail_success(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [_make_mock_env(id="env-1")]
mock_client = AsyncMock()
mock_client.get_dashboards_page.return_value = (1, [{"id": 42}])
mock_client.get_dashboard_detail.return_value = {
"id": 42,
"title": "Test Dash",
"chart_count": 5,
"dataset_count": 3,
"charts": [{"id": 1, "title": "Chart 1", "viz_type": "line"}],
"datasets": [{"id": 1, "table_name": "sales", "database": "prod"}],
}
from src.dependencies import get_config_manager
with patch("src.api.routes.dashboards._detail_routes.SupersetClient", return_value=mock_client), \
patch("src.api.routes.dashboards._detail_routes.get_superset_client") as mock_reg:
mock_reg.return_value = AsyncMock()
client = _make_client({get_config_manager: lambda: mock_config})
resp = client.get("/api/dashboards/42?env_id=env-1")
assert resp.status_code == 200
data = resp.json()
assert data["id"] == 42
def test_detail_env_not_found(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = []
from src.dependencies import get_config_manager
client = _make_client({get_config_manager: lambda: mock_config})
resp = client.get("/api/dashboards/42?env_id=env-ghost")
assert resp.status_code == 404
assert "Environment not found" in resp.text
# ── get_dashboard_tasks_history ──
class TestGetDashboardTasksHistory:
"""GET /api/dashboards/{dashboard_ref}/tasks"""
def test_tasks_history_success(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [_make_mock_env(id="env-1")]
mock_task = MagicMock()
mock_task.id = "task-1"
mock_task.plugin_id = "superset-backup"
mock_task.status = "SUCCESS"
mock_task.params = {"dashboards": ["42"], "environment_id": "env-1"}
mock_task.result = {"status": "ok", "summary": "Backup done"}
mock_task.started_at = __import__("datetime").datetime(2024, 1, 1)
mock_task.finished_at = __import__("datetime").datetime(2024, 1, 1, 0, 1)
mock_task_manager = MagicMock()
mock_task_manager.get_all_tasks.return_value = [mock_task]
from src.dependencies import get_config_manager, get_task_manager
client = _make_client({
get_config_manager: lambda: mock_config,
get_task_manager: lambda: mock_task_manager,
})
resp = client.get("/api/dashboards/42/tasks?env_id=env-1")
assert resp.status_code == 200
data = resp.json()
assert data["dashboard_id"] == 42
assert len(data["items"]) == 1
assert data["items"][0]["id"] == "task-1"
def test_tasks_history_empty(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [_make_mock_env(id="env-1")]
mock_task_manager = MagicMock()
mock_task_manager.get_all_tasks.return_value = []
from src.dependencies import get_config_manager, get_task_manager
client = _make_client({
get_config_manager: lambda: mock_config,
get_task_manager: lambda: mock_task_manager,
})
resp = client.get("/api/dashboards/42/tasks?env_id=env-1")
assert resp.status_code == 200
assert resp.json()["items"] == []
def test_tasks_history_slug_no_env_id(self):
mock_task_manager = MagicMock()
from src.dependencies import get_config_manager, get_task_manager
client = _make_client({
get_config_manager: lambda: MagicMock(),
get_task_manager: lambda: mock_task_manager,
})
resp = client.get("/api/dashboards/slug-ref/tasks")
assert resp.status_code == 400
assert "env_id is required" in resp.text
def test_tasks_history_env_not_found(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = []
from src.dependencies import get_config_manager, get_task_manager
client = _make_client({
get_config_manager: lambda: mock_config,
get_task_manager: lambda: MagicMock(),
})
resp = client.get("/api/dashboards/slug-ref/tasks?env_id=env-ghost")
assert resp.status_code == 404
assert "Environment not found" in resp.text
# ── get_dashboard_thumbnail ──
class TestGetDashboardThumbnail:
"""GET /api/dashboards/{dashboard_ref}/thumbnail"""
def test_thumbnail_success(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = [_make_mock_env(id="env-1")]
mock_client = AsyncMock()
mock_client.get_dashboards_page.return_value = (1, [{"id": 42}])
mock_async_client = AsyncMock()
async def _fake_request(method, endpoint, **kwargs):
if "cache_dashboard_screenshot" in endpoint:
return {"result": {"image_url": "/api/v1/dashboard/42/thumbnail/digest-1/"}}
if "raw_response" in kwargs and kwargs["raw_response"]:
mock_resp = MagicMock()
mock_resp.status_code = 200
mock_resp.headers = {"Content-Type": "image/png"}
mock_resp.content = b"fake-image-bytes"
return mock_resp
return {}
mock_async_client.request.side_effect = _fake_request
mock_async_client.get_dashboards_page.return_value = (1, [{"id": 42}])
from src.dependencies import get_config_manager
with patch("src.api.routes.dashboards._detail_routes.SupersetClient", return_value=mock_client), \
patch("src.api.routes.dashboards._detail_routes.get_superset_client", return_value=mock_async_client):
client = _make_client({get_config_manager: lambda: mock_config})
resp = client.get("/api/dashboards/42/thumbnail?env_id=env-1")
assert resp.status_code == 200
assert resp.content == b"fake-image-bytes"
def test_thumbnail_env_not_found(self):
mock_config = MagicMock()
mock_config.get_environments.return_value = []
from src.dependencies import get_config_manager
client = _make_client({get_config_manager: lambda: mock_config})
resp = client.get("/api/dashboards/42/thumbnail?env_id=env-ghost")
assert resp.status_code == 404
assert "Environment not found" in resp.text
# #endregion Test.Api.DashboardDetailRoutes

240
backend/tests/api/test_git_gitea_routes.py Normal file
View File

@@ -0,0 +1,240 @@
# #region Test.Api.GitGiteaRoutes [C:3] [TYPE Module] [SEMANTICS test,git,gitea,routes]
# @BRIEF Unit tests for Gitea-specific Git API routes — list, create, delete repos.
# @RELATION BINDS_TO -> [GitGiteaRoutes]
# @TEST_EDGE: config_not_found -> 404
# @TEST_EDGE: wrong_provider -> 400
# @TEST_EDGE: unsupported_provider -> 501
import os
os.environ.setdefault("DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("AUTH_DATABASE_URL", "sqlite:///:memory:")
os.environ.setdefault("SECRET_KEY", "test-secret-key-for-tests")
import sys
from pathlib import Path
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
_src = str(Path(__file__).resolve().parent.parent.parent / "src")
if _src not in sys.path:
sys.path.insert(0, _src)
def _make_mock_config(provider: str = "GITEA", pat: str = "pat-123"):
cfg = MagicMock()
cfg.id = "cfg-1"
cfg.url = "https://gitea.example.com"
cfg.pat = pat
cfg.provider = provider
return cfg
def _make_mock_gitea_repo(name: str = "my-repo") -> dict:
return {
"name": name,
"full_name": f"org/{name}",
"private": False,
"clone_url": f"https://gitea.example.com/org/{name}.git",
"html_url": f"https://gitea.example.com/org/{name}",
"ssh_url": f"git@gitea.example.com:org/{name}.git",
"default_branch": "main",
}
def _make_client(overrides: dict | None = None) -> TestClient:
from src.api.routes.git._gitea_routes import router
from src.api.routes.git._router import router as parent_router
from src.core.database import get_db
from src.dependencies import get_current_user, has_permission
from src.schemas.auth import User, RoleSchema
app = FastAPI()
app.include_router(parent_router)
app.include_router(router)
mock_user = User(
id="admin-1", username="admin", email="admin@x.com",
auth_source="LOCAL",
created_at=__import__("datetime").datetime.now(),
roles=[RoleSchema(id="r1", name="Admin", description="", permissions=[])],
)
defaults = {
get_db: lambda: MagicMock(),
get_current_user: lambda: mock_user,
}
if overrides:
defaults.update(overrides)
for dep, mock_fn in defaults.items():
app.dependency_overrides[dep] = mock_fn
return TestClient(app)
# ── list_gitea_repositories ──
class TestListGiteaRepositories:
"""GET /config/{config_id}/gitea/repos"""
def test_list_success(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config()
mock_gs = MagicMock()
mock_gs.list_gitea_repositories = AsyncMock(return_value=[_make_mock_gitea_repo()])
with patch("src.api.routes.git._gitea_routes.get_git_service", return_value=mock_gs):
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.get("/config/cfg-1/gitea/repos")
assert resp.status_code == 200
data = resp.json()
assert isinstance(data, list)
assert data[0]["name"] == "my-repo"
def test_list_config_not_found(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = None
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.get("/config/cfg-999/gitea/repos")
assert resp.status_code == 404
def test_list_wrong_provider(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config(provider="GITHUB")
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.get("/config/cfg-1/gitea/repos")
assert resp.status_code == 400
assert "GITEA provider only" in resp.text
# ── create_gitea_repository ──
class TestCreateGiteaRepository:
"""POST /config/{config_id}/gitea/repos"""
def test_create_success(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config()
mock_gs = MagicMock()
mock_gs.create_gitea_repository = AsyncMock(return_value=_make_mock_gitea_repo())
with patch("src.api.routes.git._gitea_routes.get_git_service", return_value=mock_gs):
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.post("/config/cfg-1/gitea/repos", json={
"name": "new-repo", "private": True, "auto_init": True,
})
assert resp.status_code == 200
data = resp.json()
assert data["name"] == "my-repo"
def test_create_wrong_provider(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config(provider="GITLAB")
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.post("/config/cfg-1/gitea/repos", json={
"name": "new-repo", "private": True,
})
assert resp.status_code == 400
# ── delete_gitea_repository ──
class TestDeleteGiteaRepository:
"""DELETE /config/{config_id}/gitea/repos/{owner}/{repo_name}"""
def test_delete_success(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config()
mock_gs = MagicMock()
mock_gs.delete_gitea_repository = AsyncMock(return_value=None)
with patch("src.api.routes.git._gitea_routes.get_git_service", return_value=mock_gs):
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.delete("/config/cfg-1/gitea/repos/org/my-repo")
assert resp.status_code == 200
assert resp.json()["status"] == "success"
def test_delete_wrong_provider(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config(provider="GITHUB")
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.delete("/config/cfg-1/gitea/repos/org/my-repo")
assert resp.status_code == 400
# ── create_remote_repository ──
class TestCreateRemoteRepository:
"""POST /config/{config_id}/repositories"""
def test_create_gitea_success(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config()
mock_gs = MagicMock()
mock_gs.create_gitea_repository = AsyncMock(return_value=_make_mock_gitea_repo())
with patch("src.api.routes.git._gitea_routes.get_git_service", return_value=mock_gs):
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.post("/config/cfg-1/repositories", json={
"name": "remote-repo", "private": False,
})
assert resp.status_code == 200
data = resp.json()
assert data["name"] == "my-repo"
assert data["provider"] == "GITEA"
def test_create_github_success(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config(provider="GITHUB")
mock_gs = MagicMock()
mock_gs.create_github_repository = AsyncMock(return_value=_make_mock_gitea_repo(name="gh-repo"))
with patch("src.api.routes.git._gitea_routes.get_git_service", return_value=mock_gs):
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.post("/config/cfg-1/repositories", json={
"name": "gh-repo", "private": False,
})
assert resp.status_code == 200
assert resp.json()["provider"] == "GITHUB"
def test_create_gitlab_success(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config(provider="GITLAB")
mock_gs = MagicMock()
mock_gs.create_gitlab_repository = AsyncMock(return_value=_make_mock_gitea_repo(name="gl-repo"))
with patch("src.api.routes.git._gitea_routes.get_git_service", return_value=mock_gs):
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.post("/config/cfg-1/repositories", json={
"name": "gl-repo", "private": False,
})
assert resp.status_code == 200
assert resp.json()["provider"] == "GITLAB"
def test_create_unsupported_provider(self):
mock_db = MagicMock()
mock_db.query.return_value.filter.return_value.first.return_value = _make_mock_config(provider="UNKNOWN")
from src.core.database import get_db
client = _make_client({get_db: lambda: mock_db})
resp = client.post("/config/cfg-1/repositories", json={
"name": "repo", "private": False,
})
assert resp.status_code == 501
# #endregion Test.Api.GitGiteaRoutes