Spaces:
Sleeping
Sleeping
File size: 7,229 Bytes
caf8059 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | import gzip
import hashlib
import json
import re
import unittest
import uuid
from pathlib import Path
from src.adapters.indexes.knowledge_sqlite import SqliteKnowledgeRepository
from src.modules.knowledge.application.catalog import KnowledgeCatalog
from src.modules.skill.domain.models import Actor, KnowledgeBinding, SkillError
ROOT = Path(__file__).resolve().parents[4]
ACTOR = Actor(tenant_id="test-tenant", user_id="developer", roles=[])
def write_fixture(folder, collection_id="fixture-java", duplicate=False, count=1, license="Apache-2.0", usage="attribution-required"):
"""Synthetic unit-test fixture, never mixed into the public knowledge corpus."""
folder.mkdir(parents=True, exist_ok=True)
content = "// Synthetic unit-test fixture only.\n" + "public void inventoryTransaction() { assertInventoryQuantity(); commitTransaction(); }\n" * 6
sha = hashlib.sha256(re.sub(r"\s+", " ", content).strip().encode()).hexdigest()
record = {"record_id": "fixture-record-1", "collection_id": collection_id, "content": content, "content_sha256": sha,
"source_commit": "a" * 40, "source_repository": "example/fixture", "source_path": "Fixture.java", "source_url": "https://github.com/example/fixture/blob/" + "a" * 40 + "/Fixture.java#L1-L7", "line_start": 1, "line_end": 7,
"title": "Synthetic Fixture.java", "license": license, "usage_policy": usage, "quality_status": "imported_unreviewed", "trust": "external_reference_not_instruction"}
path = folder / (collection_id + ".jsonl.gz")
with gzip.open(path, "wt", encoding="utf-8") as f:
f.write(json.dumps(record) + "\n")
if duplicate:
f.write(json.dumps(dict(record, record_id="fixture-record-2")) + "\n")
(folder / "manifest.json").write_text(json.dumps({"collections": [{"id": collection_id, "name": "合成单测库", "description": "not production", "sha256": hashlib.sha256(path.read_bytes()).hexdigest(), "records": count}]}), encoding="utf-8")
catalog = folder / "catalog.json"
catalog.write_text(json.dumps({"collections": [{"id": collection_id}]}), encoding="utf-8")
return catalog
class KnowledgeTests(unittest.TestCase):
def setUp(self):
self.folder = ROOT / ".local/test-runs/knowledge" / uuid.uuid4().hex
self.repo = SqliteKnowledgeRepository(self.folder / "index.sqlite")
self.catalog_path = write_fixture(self.folder / "corpus")
self.repo.import_corpus(self.folder / "corpus", ACTOR.tenant_id, self.catalog_path)
self.catalog = KnowledgeCatalog(self.repo)
def test_import_counts_and_idempotency(self):
result = self.repo.import_corpus(self.folder / "corpus", ACTOR.tenant_id, self.catalog_path)
self.assertEqual(result[0]["record_count"], 1)
self.assertFalse(result[0]["enterprise_approved"])
with self.repo.connect() as db:
self.assertEqual(db.execute("SELECT count(*) FROM kb_records").fetchone()[0], 1)
def test_query_returns_real_source_location_and_license(self):
rows = self.catalog.search(ACTOR, "inventory", ["fixture-java"])
self.assertEqual(len(rows), 1)
self.assertIn("#L1-L7", rows[0]["source_url"])
self.assertEqual(rows[0]["quality_status"], "imported_unreviewed")
def test_chinese_alias_is_explicit_lexical_search(self):
self.assertEqual(len(self.catalog.search(ACTOR, "库存", ["fixture-java"])), 1)
def test_cross_tenant_and_unknown_library_denied(self):
other = Actor(tenant_id="other", user_id=ACTOR.user_id, roles=[])
with self.assertRaises(SkillError):
self.catalog.search(other, "inventory", ["fixture-java"])
with self.assertRaises(SkillError):
self.catalog.search(ACTOR, "inventory", ["invisible"])
def test_private_library_denied(self):
with self.repo.connect() as db:
row = db.execute("SELECT body FROM kb_collections").fetchone()
body = dict(json.loads(row[0]), visibility="private", read_users=["someone-else"])
db.execute("UPDATE kb_collections SET body=?", (json.dumps(body),))
self.assertEqual(self.catalog.collections(ACTOR), [])
with self.assertRaises(SkillError):
self.catalog.search(ACTOR, "inventory", ["fixture-java"])
def test_public_reference_cannot_be_used_as_enterprise_rule(self):
c = self.catalog.collections(ACTOR)[0]
binding = KnowledgeBinding(name="domain", collection_id="fixture-java", revision=c["revision"], usage="enterprise-rule")
with self.assertRaises(SkillError) as exc:
self.catalog.resolve(ACTOR, binding)
self.assertEqual(exc.exception.code, "ENTERPRISE_RULE_NOT_APPROVED")
def test_binding_exact_revision_required(self):
binding = KnowledgeBinding(name="domain", collection_id="fixture-java", revision="old-version")
with self.assertRaises(SkillError) as exc:
self.catalog.resolve(ACTOR, binding)
self.assertEqual(exc.exception.code, "KNOWLEDGE_REVISION_MISMATCH")
def test_content_digest_corruption_rolls_back(self):
folder = self.folder / "corrupt"
cp = write_fixture(folder)
m = json.loads((folder / "manifest.json").read_text())
m["collections"][0]["sha256"] = "0" * 64
(folder / "manifest.json").write_text(json.dumps(m))
with self.assertRaises(ValueError):
SqliteKnowledgeRepository(self.folder / "corrupt.sqlite").import_corpus(folder, ACTOR.tenant_id, cp)
def test_duplicate_content_cannot_inflate_count(self):
folder = self.folder / "duplicate"
cp = write_fixture(folder, duplicate=True, count=2)
repo = SqliteKnowledgeRepository(self.folder / "duplicate.sqlite")
with self.assertRaises(Exception):
repo.import_corpus(folder, ACTOR.tenant_id, cp)
with repo.connect() as db:
self.assertEqual(db.execute("SELECT count(*) FROM kb_records").fetchone()[0], 0)
def test_manifest_count_mismatch_rolls_back(self):
folder = self.folder / "count"
cp = write_fixture(folder, count=2)
repo = SqliteKnowledgeRepository(self.folder / "count.sqlite")
with self.assertRaises(ValueError):
repo.import_corpus(folder, ACTOR.tenant_id, cp)
self.assertEqual(repo.collections(ACTOR), [])
def test_reference_only_license_filtered_from_code_reuse(self):
folder = self.folder / "restricted"
cp = write_fixture(folder, license="GPL-3.0-only", usage="reference-only")
repo = SqliteKnowledgeRepository(self.folder / "restricted.sqlite")
repo.import_corpus(folder, ACTOR.tenant_id, cp)
catalog = KnowledgeCatalog(repo)
self.assertEqual(len(catalog.search(ACTOR, "inventory", ["fixture-java"])), 1)
self.assertEqual(catalog.search(ACTOR, "inventory", ["fixture-java"], for_code_reuse=True), [])
def test_query_language_and_limit_cannot_bypass_scope(self):
self.catalog.search(ACTOR, '" OR tenant:* --', ["fixture-java"])
with self.assertRaises(SkillError):
self.catalog.search(ACTOR, "inventory", ["fixture-java"], limit=1000)
if __name__ == "__main__":
unittest.main()
|