Spaces:
Sleeping
Sleeping
Download src/modules/skill/tests/test_skill.py from dellweb3/VibeCoding: direct link, hf CLI and curl.
- Browser
- Download file 15.9 kB
-
https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/modules/skill/tests/test_skill.py
- Command line
-
hf download hf://spaces/dellweb3/VibeCoding/src/modules/skill/tests/test_skill.py
-
curl -L -o test_skill.py https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/modules/skill/tests/test_skill.py
15.9 kB
| """Business invariant tests; no model calls, Java runs or source-download execution.""" | |
| import copy | |
| import tempfile | |
| import unittest | |
| import uuid | |
| from concurrent.futures import ThreadPoolExecutor | |
| from pathlib import Path | |
| from types import SimpleNamespace | |
| from pydantic import ValidationError | |
| from src.adapters.persistence.skill_sqlite import SqliteSkillRepository | |
| from src.modules.skill.application.service import SkillService | |
| from src.modules.skill.atomic_registry.catalog import builtin_operations, check_handler | |
| from src.modules.skill.domain.models import Actor, Budget, Draft, Framework, Operation, SkillError, fits | |
| from src.modules.skill.graph.compiler import compile_graph | |
| from src.modules.skill.packs.examples import all_examples, framework_candidate | |
| ADMIN = Actor(tenant_id="test-tenant", user_id="author", roles=["admin"]) | |
| REVIEWER = Actor(tenant_id="test-tenant", user_id="reviewer", roles=["reviewer"]) | |
| USER = Actor(tenant_id="test-tenant", user_id="developer", roles=[]) | |
| OTHER = Actor(tenant_id="another-tenant", user_id="author", roles=["admin"]) | |
| REVISIONS = {c: "test-revision-1" for c in ["java-basics", "java-patterns", "erp", "wms", "equipment-ops", "java-frameworks", "web-development", "java-persistence", "java-testing", "java-integration"]} | |
| class KnowledgeDouble: | |
| def __init__(self): | |
| self.allowed = True | |
| self.revision = "test-revision-1" | |
| def __call__(self, actor, binding): | |
| if not self.allowed: | |
| raise SkillError("KNOWLEDGE_NOT_FOUND", "test denied", 404) | |
| if binding.revision != self.revision: | |
| raise SkillError("KNOWLEDGE_REVISION_MISMATCH", "test changed", 409) | |
| return {"id": binding.collection_id, "revision": self.revision, "digest": "a" * 64, "scope": binding.usage} | |
| def approved_framework(): | |
| return framework_candidate().model_copy(update={"state": "approved", "evidence_refs": ["unit-test-fixture-not-production-certification"]}) | |
| class CompilerTests(unittest.TestCase): | |
| def setUp(self): | |
| self.draft = all_examples(REVISIONS)[0] | |
| self.ops = {o.operation_id + "@" + o.version: o for o in builtin_operations()} | |
| def report(self, data=None): | |
| return compile_graph(Draft.model_validate(data) if data else self.draft, self.ops, approved_framework()) | |
| def codes(self, data): | |
| return {x.code for x in self.report(data).issues} | |
| def test_three_domain_flows_compile_and_share_operations(self): | |
| for draft in all_examples(REVISIONS): | |
| report = compile_graph(draft, self.ops, approved_framework()) | |
| self.assertTrue(report.valid, report.issues) | |
| self.assertEqual(report.model_calls, 2) | |
| self.assertEqual(len(report.execution_order), 16) | |
| def test_cycle_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["control_edges"].append({"source": "end", "target": "start"}) | |
| self.assertIn("CONTROL_CYCLE", self.codes(data)) | |
| def test_duplicate_node_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["nodes"].append(data["graph"]["nodes"][0]) | |
| self.assertIn("DUPLICATE_NODE", self.codes(data)) | |
| def test_unknown_node_and_duplicate_edge_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["control_edges"] += [{"source": "unknown", "target": "end"}, data["graph"]["control_edges"][0]] | |
| self.assertTrue({"UNKNOWN_NODE", "DUPLICATE_EDGE"}.issubset(self.codes(data))) | |
| def test_disconnected_node_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["nodes"].append({"id": "orphan", "kind": "approval", "approval_scope": "design"}) | |
| self.assertIn("DISCONNECTED_NODE", self.codes(data)) | |
| def test_type_mismatch_and_reverse_data_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["data_edges"][0]["source_port"] = "query" | |
| data["graph"]["data_edges"][0]["source"] = "end" | |
| self.assertTrue({"UNKNOWN_PORT", "DATA_ORDER"}.issubset(self.codes(data))) | |
| data = self.draft.model_dump() | |
| data["graph"]["data_edges"][0].update(source="requirements", source_port="document", target="knowledge", target_port="query") | |
| self.assertIn("PORT_TYPE_MISMATCH", self.codes(data)) | |
| def test_unknown_operation_and_framework_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["nodes"][1]["operation_ref"] = "unapproved@1.0.0" | |
| self.assertIn("OPERATION_UNAVAILABLE", self.codes(data)) | |
| self.assertIn("FRAMEWORK_UNAVAILABLE", {x.code for x in compile_graph(self.draft, self.ops, framework_candidate()).issues}) | |
| def test_missing_input_and_duplicate_binding_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["data_edges"].pop(0) | |
| self.assertIn("REQUIRED_INPUT", self.codes(data)) | |
| data = self.draft.model_dump() | |
| data["graph"]["data_edges"].append(copy.deepcopy(data["graph"]["data_edges"][0])) | |
| self.assertIn("MULTIPLE_INPUT_SOURCES", self.codes(data)) | |
| def test_literal_cannot_forge_test_evidence(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["data_edges"] = [e for e in data["graph"]["data_edges"] if not(e["target"] == "preview" and e["target_port"] == "test_evidence")] | |
| next(n for n in data["graph"]["nodes"] if n["id"] == "preview")["inputs"] = {"test_evidence": {"passed": True}} | |
| self.assertIn("UNTRUSTED_STAGE_INPUT", self.codes(data)) | |
| def test_object_port_cannot_substitute_for_test_evidence(self): | |
| data = self.draft.model_dump() | |
| edge = next(e for e in data["graph"]["data_edges"] if e["target"] == "preview" and e["target_port"] == "test_evidence") | |
| edge.update(source="design", source_port="design") | |
| self.assertIn("UNTRUSTED_STAGE_INPUT", self.codes(data)) | |
| def test_design_and_execution_gates_must_dominate_all_paths(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["control_edges"].append({"source": "design", "target": "patch"}) | |
| self.assertTrue({"DESIGN_GATE_BYPASS", "EXECUTION_GATE_BYPASS"}.issubset(self.codes(data))) | |
| def test_test_gate_must_dominate_preview(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["control_edges"].append({"source": "build", "target": "preview"}) | |
| self.assertIn("QUALITY_GATE_BYPASS", self.codes(data)) | |
| def test_acceptance_cannot_be_bypassed(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["control_edges"].append({"source": "preview", "target": "evidence"}) | |
| self.assertIn("ACCEPTANCE_GATE_BYPASS", self.codes(data)) | |
| def test_incomplete_flow_and_forged_end_manifest_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["control_edges"].append({"source": "start", "target": "end"}) | |
| self.assertIn("INCOMPLETE_CODING_FLOW", self.codes(data)) | |
| data = self.draft.model_dump() | |
| data["graph"]["data_edges"][-1].update(source="design", source_port="design") | |
| self.assertIn("UNTRUSTED_MANIFEST", self.codes(data)) | |
| def test_resources_cannot_reference_unbound_collection(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["resource_edges"][0]["resource"] = "secret" | |
| self.assertIn("RESOURCE_REFERENCE", self.codes(data)) | |
| def test_budget_must_include_shared_repair_reserve(self): | |
| data = self.draft.model_dump() | |
| data["budget"]["max_repairs"] = 2 | |
| self.assertIn("BUDGET_UNREACHABLE", self.codes(data)) | |
| self.assertEqual(Budget().max_model_calls,3) | |
| data['budget']=Budget(max_model_calls=6,max_tokens=120000,max_repairs=2).model_dump() | |
| self.assertNotIn('BUDGET_UNREACHABLE',self.codes(data)) | |
| with self.assertRaises(ValidationError): | |
| Budget(max_model_calls=7) | |
| def test_unknown_executable_fields_and_weak_handler_contract_rejected(self): | |
| data = self.draft.model_dump() | |
| data["graph"]["nodes"][1]["script"] = "arbitrary code" | |
| with self.assertRaises(ValidationError): | |
| Draft.model_validate(data) | |
| operation = builtin_operations()[5].model_copy(update={"permissions": []}) | |
| with self.assertRaises(SkillError): | |
| check_handler(operation) | |
| def test_boolean_is_not_integer_and_unsafe_framework_paths_rejected(self): | |
| self.assertFalse(fits(True, "integer")) | |
| self.assertFalse(fits(float("nan"), "number")) | |
| for path in ["../", "/etc/", "runner/", "src/main/../../"]: | |
| with self.subTest(path=path), self.assertRaises(ValidationError): | |
| Framework(profile_id="unsafe", version="0.1.0", allowed_paths=[path]) | |
| class ServiceTests(unittest.TestCase): | |
| def setUp(self): | |
| folder = Path(__file__).resolve().parents[4] / ".local/test-runs/skill" / uuid.uuid4().hex | |
| folder.mkdir(parents=True) | |
| self.tmp = SimpleNamespace(name=str(folder)) | |
| self.repo = SqliteSkillRepository(Path(self.tmp.name) / "skill.sqlite") | |
| self.knowledge = KnowledgeDouble() | |
| self.access = lambda actor, pid: self.assertEqual(pid, "project-one") | |
| self.service = SkillService(self.repo, self.knowledge, self.access) | |
| self.service.bootstrap(ADMIN) | |
| self.service.add_framework(ADMIN, approved_framework()) | |
| self.draft = all_examples(REVISIONS)[0] | |
| self.saved = self.service.save_draft(ADMIN, self.draft) | |
| def publish(self): | |
| report = self.service.validate(ADMIN, self.draft.skill_id) | |
| approval = self.service.approve(REVIEWER, self.draft.skill_id, 1, report.digest, ["unit-test-evidence"]) | |
| return self.service.publish(ADMIN, self.draft.skill_id, "0.1.0", 1, approval["key"]) | |
| def test_draft_cas_does_not_overwrite(self): | |
| changed = self.draft.model_copy(update={"description": "updated"}) | |
| result = self.service.save_draft(ADMIN, changed, 1) | |
| self.assertEqual(result["revision"], 2) | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.save_draft(ADMIN, self.draft, 1) | |
| self.assertEqual(exc.exception.code, "REVISION_CONFLICT") | |
| def test_concurrent_cas_has_one_winner(self): | |
| def update(label): | |
| try: | |
| self.service.save_draft(ADMIN, self.draft.model_copy(update={"description": label}), 1) | |
| return "won" | |
| except SkillError as exc: | |
| return exc.code | |
| with ThreadPoolExecutor(max_workers=2) as pool: | |
| results = list(pool.map(update, ["one", "two"])) | |
| self.assertCountEqual(results, ["won", "REVISION_CONFLICT"]) | |
| def test_cross_tenant_and_regular_user_denied(self): | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.read_draft(OTHER, self.draft.skill_id) | |
| self.assertEqual(exc.exception.status, 404) | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.save_draft(USER, self.draft) | |
| self.assertEqual(exc.exception.status, 403) | |
| def test_author_cannot_approve_own_revision(self): | |
| report = self.service.validate(ADMIN, self.draft.skill_id) | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.approve(ADMIN, self.draft.skill_id, 1, report.digest, ["test"]) | |
| self.assertEqual(exc.exception.code, "INDEPENDENT_REVIEW_REQUIRED") | |
| def test_last_editor_cannot_approve_others_original_draft(self): | |
| other = Actor(tenant_id=ADMIN.tenant_id, user_id="editor-two", roles=["admin"]) | |
| self.service.save_draft(other, self.draft, 1) | |
| report = self.service.validate(other, self.draft.skill_id) | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.approve(other, self.draft.skill_id, 2, report.digest, ["test"]) | |
| self.assertEqual(exc.exception.code, "INDEPENDENT_REVIEW_REQUIRED") | |
| def test_approval_invalidated_by_draft_change(self): | |
| report = self.service.validate(ADMIN, self.draft.skill_id) | |
| approval = self.service.approve(REVIEWER, self.draft.skill_id, 1, report.digest, ["test"]) | |
| self.service.save_draft(ADMIN, self.draft.model_copy(update={"description": "changed"}), 1) | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.publish(ADMIN, self.draft.skill_id, "0.1.0", 2, approval["key"]) | |
| self.assertEqual(exc.exception.code, "APPROVAL_TARGET_CHANGED") | |
| def test_releases_are_immutable_and_new_drafts_do_not_change_them(self): | |
| release = self.publish() | |
| self.service.save_draft(ADMIN, self.draft.model_copy(update={"description": "new design"}), 1) | |
| self.assertEqual(self.service.releases(USER)[0]["digest"], release["digest"]) | |
| with self.repo.transaction(write=True) as tx, self.assertRaises(SkillError): | |
| tx.update(ADMIN.tenant_id, "release", release["key"], {}, 1) | |
| def test_duplicate_release_cannot_replace_history(self): | |
| release = self.publish() | |
| with self.repo.transaction(write=True) as tx, self.assertRaises(SkillError) as exc: | |
| tx.create(ADMIN.tenant_id, "release", release["key"], {}) | |
| self.assertEqual(exc.exception.code, "VERSION_EXISTS") | |
| def test_stop_new_snapshots_for_retired_dependencies(self): | |
| release = self.publish() | |
| self.service.retire(ADMIN, "operation", "AO09@0.1.0", "test retirement") | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.prepare(USER, release["key"], "project-one", "a" * 64, "request-one") | |
| self.assertEqual(exc.exception.code, "DEPENDENCY_RETIRED") | |
| def test_knowledge_revocation_is_rechecked_at_start(self): | |
| release = self.publish() | |
| self.knowledge.allowed = False | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.prepare(USER, release["key"], "project-one", "a" * 64, "request-one") | |
| self.assertEqual(exc.exception.status, 404) | |
| def test_snapshot_idempotency_and_source_binding(self): | |
| release = self.publish() | |
| first = self.service.prepare(USER, release["key"], "project-one", "a" * 64, "request-one") | |
| replay = self.service.prepare(USER, release["key"], "project-one", "a" * 64, "request-one") | |
| self.assertEqual(first, replay) | |
| self.assertEqual(first["execution_status"], "not_started") | |
| with self.assertRaises(SkillError) as exc: | |
| self.service.prepare(USER, release["key"], "project-one", "b" * 64, "request-one") | |
| self.assertEqual(exc.exception.code, "IDEMPOTENCY_CONFLICT") | |
| def test_restart_keeps_data_and_does_not_execute(self): | |
| release = self.publish() | |
| restarted = SkillService(SqliteSkillRepository(self.repo.path), self.knowledge, self.access) | |
| self.assertEqual(restarted.releases(USER)[0]["key"], release["key"]) | |
| with self.repo.transaction() as tx: | |
| self.assertEqual(tx.listing(ADMIN.tenant_id, "snapshot"), []) | |
| def test_invisible_knowledge_fails_validation(self): | |
| self.knowledge.allowed = False | |
| report = self.service.validate(ADMIN, self.draft.skill_id) | |
| self.assertFalse(report.valid) | |
| self.assertIn("KNOWLEDGE_NOT_FOUND", {i.code for i in report.issues}) | |
| def test_mutable_framework_dependencies_rejected(self): | |
| for version in ["latest", "[1.0,2.0)", "1.0-SNAPSHOT", "approved-version"]: | |
| framework = approved_framework().model_copy(update={"version": "0.2.0", "dependencies": {"example:library": version}}) | |
| with self.subTest(version=version), self.assertRaises(SkillError): | |
| self.service.add_framework(ADMIN, framework) | |
| def test_retirement_does_not_erase_release_evidence(self): | |
| release = self.publish() | |
| self.service.retire(ADMIN, "release", release["key"], "disabled for test") | |
| self.assertEqual(self.service.releases(USER), []) | |
| with self.repo.transaction() as tx: | |
| self.assertIsNotNone(tx.get(ADMIN.tenant_id, "release", release["key"])) | |
| if __name__ == "__main__": | |
| unittest.main() | |