Spaces:
Sleeping
Sleeping
Download KnowledgeService/tests/test_corpus_acceptance.py from dellweb3/workos-office: direct link, hf CLI and curl.
- Browser
- Download file 7.98 kB
-
https://huggingface.co/spaces/dellweb3/workos-office/resolve/main/KnowledgeService/tests/test_corpus_acceptance.py
- Command line
-
hf download hf://spaces/dellweb3/workos-office/KnowledgeService/tests/test_corpus_acceptance.py
-
curl -L -o test_corpus_acceptance.py https://huggingface.co/spaces/dellweb3/workos-office/resolve/main/KnowledgeService/tests/test_corpus_acceptance.py
7.98 kB
| """Customer-facing corpus evidence: integrity, restart, permissions and useful facts.""" | |
| import hashlib,json,tempfile,unittest,os,uuid | |
| from pathlib import Path | |
| from unittest.mock import patch | |
| from sqlalchemy import select,func,delete,event | |
| from WorkspaceService.workspace_service import WorkspaceService | |
| from KnowledgeService import KnowledgeService,KnowledgeError | |
| from KnowledgeService.models import Document,DocumentSource,Grant,KnowledgeBase | |
| from KnowledgeService.seed import inventory,corpus_plan,checked_file,ROOT | |
| A={'tenant_id':'demo-tenant','user_id':'u-lin'} | |
| ADMIN={**A,'user_id':'u-admin','roles':['admin']} | |
| class CorpusAcceptance(unittest.TestCase): | |
| def setUp(self): | |
| self.tmp=tempfile.TemporaryDirectory() | |
| self.ws=WorkspaceService(database_url='sqlite:///'+self.tmp.name+'/db.sqlite',file_root=self.tmp.name+'/files',auto_create_schema=True) | |
| self.k=KnowledgeService(self.ws) | |
| self.wid=self.ws.create(A,'星河合成验收',uuid.uuid4().hex)[0]['workspace_id'] | |
| def tearDown(self):self.ws.engine.dispose();self.tmp.cleanup() | |
| def test_inventory_all_five_libraries_and_honest_categories(self): | |
| value=inventory() | |
| self.assertEqual(value['shared_count'],69) | |
| self.assertEqual(value['private_fixture_count'],4) | |
| self.assertEqual(len(value['base_counts']),5) | |
| self.assertEqual(value['origin_counts'],{'open_license':24,'official_reference':2,'synthetic':43,'unverified':0}) | |
| self.assertTrue(all(r['provenance']['content_sha256'] for r in value['items'])) | |
| self.assertEqual(value['outdated_imported_count'],0) | |
| self.assertEqual(sum(s['status']=='superseded' for s in value['authority']['sources']),2) | |
| def test_repeated_startup_is_idempotent_and_provenance_persists(self): | |
| before=self.k.documents(A,self.wid) | |
| other=KnowledgeService(self.ws) | |
| self.assertEqual(before,other.documents(A,self.wid)) | |
| with self.ws.Session() as db: | |
| self.assertEqual(db.scalar(select(func.count()).select_from(DocumentSource)),69) | |
| for d in db.scalars(select(Document)): | |
| self.assertEqual(db.get(DocumentSource,d.id).body['content_sha256'],d.sha256) | |
| def test_guide_hash_is_guide_not_original(self): | |
| for r in corpus_plan(): | |
| self.assertEqual(r['provenance']['content_sha256'],hashlib.sha256(r['content']).hexdigest()) | |
| if r['source_type']=='open_source_guide':self.assertNotEqual(r['provenance']['origin_sha256'],r['provenance']['content_sha256']) | |
| def test_corrupt_bundle_is_rejected_before_writes(self): | |
| # A late failure must not leave bases/documents half initialized. | |
| clean=WorkspaceService(database_url='sqlite:///'+self.tmp.name+'/clean.sqlite',file_root=self.tmp.name+'/clean',auto_create_schema=True) | |
| try: | |
| with patch('KnowledgeService.seed.corpus_plan',side_effect=KnowledgeError(422,'SEED_HASH_MISMATCH','corrupt')): | |
| with self.assertRaises(KnowledgeError):KnowledgeService(clean) | |
| with clean.Session() as db:self.assertEqual(db.scalar(select(func.count()).select_from(KnowledgeBase)),0) | |
| finally:clean.engine.dispose() | |
| def test_path_escape_and_tamper_fail_closed(self): | |
| folder=Path(self.tmp.name);(folder/'sample.md').write_text('sample') | |
| for name,sha in [('sample.md','bad'),('../db.sqlite',None)]: | |
| with self.assertRaises(KnowledgeError):checked_file(folder,name,sha) | |
| def test_source_and_document_are_one_transaction(self): | |
| original=self.k._info | |
| def fail(*args):raise RuntimeError('simulated disk/database failure') | |
| with patch.object(self.k,'_info',side_effect=fail): | |
| with self.assertRaises(RuntimeError):self.k._save(tenant='demo-tenant',document_id='rollback-test',version='1',base_id='kb-rules',title='rollback',content=b'body',filename='test.md',provenance={'origin_kind':'synthetic'}) | |
| with self.ws.Session() as db:self.assertIsNone(db.scalar(select(Document).where(Document.document_id=='rollback-test'))) | |
| def test_synthetic_questions_have_specific_citable_answers(self): | |
| cases=[('星河 跨部门 通知 签发','synthetic-xh-document-policy','陈明'),('星河 一般 通知 审校 期限','synthetic-xh-document-policy','1个工作日'),('星河 归档 截止 清单','synthetic-xh-archive-sop','2026年10月20日17:00'),('星河 财务凭证 索引','synthetic-xh-archive-sop','不重复复制'),('星河 归档 缺件 延期','synthetic-xh-archive-sop','陈明')] | |
| for query,did,fact in cases: | |
| with self.subTest(query=query): | |
| hits=self.k.search(A,self.wid,query,[],3)['items'] | |
| selected=[h for h in hits if h['document_id']==did] | |
| self.assertTrue(selected,[h['title'] for h in hits]) | |
| self.assertTrue(any(fact in self.k.citation(A,h['citation_id'],self.wid)['text'] for h in selected)) | |
| self.assertTrue(all(h['provenance']['origin_kind']=='synthetic' for h in selected)) | |
| def test_revocation_blocks_provenance_and_original_too(self): | |
| h=self.k.search(A,self.wid,'星河 通知 签发',['kb-rules'],1)['items'][0] | |
| with self.ws.Session.begin() as db:db.execute(delete(Grant).where(Grant.tenant=='demo-tenant',Grant.base_id=='kb-rules',Grant.user_id=='u-lin')) | |
| for read in [lambda:self.k.citation(A,h['citation_id'],self.wid),lambda:self.k.original(A,h['citation_id'],self.wid)]: | |
| with self.assertRaises(KnowledgeError) as ctx:read() | |
| self.assertEqual(ctx.exception.status,404) | |
| def test_admin_catalog_excludes_private_fixtures_and_requires_admin(self): | |
| with self.assertRaises(KnowledgeError):self.k.source_catalog(A) | |
| catalog=self.k.source_catalog(ADMIN) | |
| self.assertEqual(len(catalog['items']),69) | |
| self.assertTrue(all(not r['private'] for r in catalog['items'])) | |
| docs=self.k.admin_documents(ADMIN,'kb-rules')['items'] | |
| d=next(r for r in docs if r['document_id']=='synthetic-xh-document-policy') | |
| self.assertEqual(self.k.preview(ADMIN,d['document_key'])['provenance'],d['provenance']) | |
| def test_admin_document_list_uses_bounded_queries(self): | |
| calls=[] | |
| def record(*args):calls.append(1) | |
| event.listen(self.ws.engine,'before_cursor_execute',record) | |
| try:self.k.admin_documents(ADMIN,'kb-rules') | |
| finally:event.remove(self.ws.engine,'before_cursor_execute',record) | |
| self.assertLessEqual(len(calls),6) | |
| def test_upgrade_preserves_crlf_immutable_versions(self): | |
| from KnowledgeService.seed import import_catalog | |
| r=next(r for r in corpus_plan() if r['document_id']=='synthetic-xh-document-policy') | |
| # A previous Windows bundle stored CRLF in an immutable v1. | |
| other=WorkspaceService(database_url='sqlite:///'+self.tmp.name+'/upgrade.sqlite',file_root=self.tmp.name+'/upgrade',auto_create_schema=True) | |
| try: | |
| k=KnowledgeService(other,seed_demo=False) | |
| with other.Session.begin() as db:db.add(KnowledgeBase(tenant='demo-tenant',id=r['base_id'],name='upgrade',visibility='shared')) | |
| raw=r['content'].replace(b'\n',b'\r\n') | |
| old=k._save(tenant='demo-tenant',document_id=r['document_id'],version=r['version'],base_id=r['base_id'],title=r['title'],content=raw,filename=r['filename'],source_type='synthetic_demo') | |
| import_catalog(k,[r]);import_catalog(k,[r]) | |
| with other.Session() as db: | |
| self.assertEqual(db.get(Document,old.id).sha256,hashlib.sha256(raw).hexdigest()) | |
| source=db.get(DocumentSource,old.id).body | |
| self.assertEqual(source['content_sha256'],hashlib.sha256(raw).hexdigest()) | |
| self.assertEqual(source['bundle_sha256'],hashlib.sha256(r['content']).hexdigest()) | |
| finally:other.engine.dispose() | |