132 lines
8.2 KiB
Python
132 lines
8.2 KiB
Python
import io
|
|
import json
|
|
from unittest.mock import Mock, patch
|
|
|
|
from rest_framework.test import APIRequestFactory, force_authenticate
|
|
from system_manage import test_my_mindmaps as fixtures
|
|
from system_manage import ai_hub as hub
|
|
from system_manage.ai_hub_worker import execute
|
|
from system_manage.heading_structure import artifact_state, analyze, manual_edit
|
|
from system_manage.models.ai_hub import AITask
|
|
from system_manage.views.ai_hub import HubView
|
|
|
|
|
|
class HeadingApiChecks(fixtures.MyMindmapsChecks):
|
|
def heading_api(self, user, data, workspace='default'):
|
|
request = APIRequestFactory().post('/', data, format='json')
|
|
force_authenticate(request, user=user)
|
|
response = HubView.as_view()(request, workspace_id=workspace, kind='heading_structure')
|
|
return json.loads(response.content) if hasattr(response, 'content') else response.data
|
|
|
|
def test_cross_user_and_workspace_task_or_artifact_evidence_is_denied(self):
|
|
for data in ({'artifact_id': str(self.c.id)}, {'artifact_id': str(self.d.id)}):
|
|
result = self.heading_api(self.user, {'mode': 'inspect', 'markdown': '# A', **data})
|
|
self.assertNotEqual(result.get('code'), 200)
|
|
task = AITask.objects.create(workspace_id='default', owner_id=self.other.id, name='other', status='SUCCESS')
|
|
self.assertNotEqual(self.heading_api(self.user, {'mode': 'inspect', 'markdown': '# A', 'task_id': str(task.id)}).get('code'), 200)
|
|
|
|
def test_rules_manual_save_reopen_and_history_keep_original_and_locks(self):
|
|
raw = '# 1 Root\n# 1.1 Child\nBody42\n'
|
|
value = self.heading_api(self.user, {'mode': 'rules', 'markdown': raw})['data']
|
|
self.assertIn('## 1.1 Child', value['markdown'])
|
|
row = next(h for h in value['heading_structure']['headings'] if h['text'] == '1.1 Child')
|
|
manual = self.heading_api(self.user, {'mode': 'manual', **value,
|
|
'action': {'kind': 'confirm', 'id': row['id']}})['data']
|
|
saved = hub.artifact_save('default', self.user, {'name': 'outline', 'original': raw,
|
|
'markdown': manual['markdown'], 'heading_structure': manual['heading_structure']})
|
|
saved.refresh_from_db()
|
|
self.assertEqual(saved.original, raw)
|
|
self.assertIn(row['id'], artifact_state(saved)['manual'])
|
|
second = hub.artifact_save('default', self.user, {'name': 'outline', 'revision': saved.revision,
|
|
'markdown': saved.markdown + '\nExtra body', 'heading_structure': artifact_state(saved)}, saved)
|
|
serialized = hub.serialize(second, detail=True)
|
|
self.assertEqual(len(serialized['history']), 0)
|
|
self.assertIn(row['id'], serialized['heading_structure']['manual'])
|
|
reopened = self.heading_api(self.user, {'mode': 'rules', 'markdown': second.markdown,
|
|
'artifact_id': str(second.id), 'heading_structure': serialized['heading_structure']})['data']
|
|
self.assertIn(row['id'], reopened['heading_structure']['manual'])
|
|
|
|
def test_model_repair_uses_durable_job_and_records_validated_output(self):
|
|
from models_provider.models import Model
|
|
model = Model.objects.create(name='outline-model', model_type='LLM', model_name='test',
|
|
provider='test', user_id=self.user.id, credential='unused', status='SUCCESS', model_params_form=[])
|
|
def invoke(messages):
|
|
payload = json.loads(messages[-1].content)
|
|
return Mock(content=json.dumps([{'id': r['id'], 'level': i + 1} for i, r in enumerate(payload['batch'])]), response_metadata={})
|
|
instance = Mock(); instance.invoke.side_effect = invoke
|
|
with patch('system_manage.ai_hub.model_for', return_value=model), patch('models_provider.tools.get_model', return_value=instance), patch('models_provider.tools.get_model_default_params', return_value={'max_tokens': 1024}):
|
|
result = self.heading_api(self.user, {'mode': 'model', 'markdown': '# Root\n# Child\nBody42', 'model_id': str(model.id)})['data']
|
|
task = AITask.objects.get(pk=result['task_id'])
|
|
self.assertEqual(task.status, 'PENDING')
|
|
self.assertEqual(task.snapshot['nodes'][0]['operation'], 'heading_repair')
|
|
task.status = 'RUNNING'; task.save()
|
|
execute(task)
|
|
task.refresh_from_db()
|
|
self.assertEqual(task.status, 'SUCCESS', task.error)
|
|
self.assertIn('## Child', task.result['markdown'])
|
|
self.assertEqual(task.result['source']['heading_structure']['model']['status'], 'applied')
|
|
self.assertEqual(task.result['original'], '# Root\n# Child\nBody42')
|
|
|
|
def test_native_word_custom_outline_inheritance_and_numbering(self):
|
|
from docx import Document
|
|
from docx.enum.style import WD_STYLE_TYPE
|
|
from docx.oxml import OxmlElement
|
|
from docx.oxml.ns import qn
|
|
from system_manage.parsers.native import parse
|
|
document = Document()
|
|
style = document.styles.add_style('CustomOutline', WD_STYLE_TYPE.PARAGRAPH)
|
|
element = OxmlElement('w:outlineLvl'); element.set(qn('w:val'), '2')
|
|
style.element.get_or_add_pPr().append(element)
|
|
inherited = document.styles.add_style('InheritedOutline', WD_STYLE_TYPE.PARAGRAPH); inherited.base_style = style
|
|
document.add_paragraph('Inherited section', style=inherited)
|
|
numbering = document.part.numbering_part.element
|
|
abstract = OxmlElement('w:abstractNum'); abstract.set(qn('w:abstractNumId'), '999')
|
|
for i in range(2):
|
|
level = OxmlElement('w:lvl'); level.set(qn('w:ilvl'), str(i))
|
|
for tag, val in [('w:start', '1'), ('w:numFmt', 'decimal'), ('w:lvlText', '%1' if i == 0 else '%1.%2')]:
|
|
e = OxmlElement(tag); e.set(qn('w:val'), val); level.append(e)
|
|
abstract.append(level)
|
|
numbering.append(abstract)
|
|
num = OxmlElement('w:num'); num.set(qn('w:numId'), '999')
|
|
aid = OxmlElement('w:abstractNumId'); aid.set(qn('w:val'), '999'); num.append(aid); numbering.append(num)
|
|
paragraph = document.add_paragraph('Numbered section', style='Heading 2')
|
|
prop = OxmlElement('w:numPr')
|
|
for tag, val in [('w:ilvl', '1'), ('w:numId', '999')]:
|
|
e = OxmlElement(tag); e.set(qn('w:val'), val); prop.append(e)
|
|
paragraph._p.get_or_add_pPr().append(prop)
|
|
buffer = io.BytesIO(); document.save(buffer)
|
|
parsed = parse('outline.docx', buffer.getvalue())
|
|
self.assertIn('### Inherited section', parsed['markdown'])
|
|
self.assertIn('## 1.1 Numbered section', parsed['markdown'])
|
|
|
|
def test_unavailable_optional_model_keeps_parsed_document(self):
|
|
from system_manage.heading_service import invoke_model
|
|
with patch('system_manage.ai_hub.model_for', side_effect=RuntimeError('private-provider-details')):
|
|
value = invoke_model('default', self.user, {'model_id': 'missing'}, '# Root\n# Child\nBody42', {}, None, None)
|
|
self.assertIn('Body42', value['text'])
|
|
self.assertEqual(value['structured']['heading_structure']['model']['status'], 'fallback')
|
|
self.assertNotIn('private-provider-details', json.dumps(value))
|
|
|
|
def test_high_confidence_rules_do_not_call_any_model(self):
|
|
from system_manage.heading_service import invoke_model
|
|
with patch('system_manage.ai_hub.model_for') as model:
|
|
value = invoke_model('default', self.user, {}, '# 1 Root\n# 1.1 Child\n', {}, None, None)
|
|
model.assert_not_called()
|
|
self.assertIn('## 1.1 Child', value['text'])
|
|
self.assertEqual(value['structured']['heading_structure']['model']['status'], 'skipped')
|
|
|
|
def test_native_pdf_keeps_bookmarks_and_font_evidence(self):
|
|
import fitz
|
|
from system_manage.parsers.native import parse
|
|
document = fitz.open(); page = document.new_page()
|
|
page.insert_text((50, 60), 'Root', fontsize=22)
|
|
page.insert_text((50, 95), 'Child', fontsize=16)
|
|
page.insert_text((50, 130), 'Body value 42.', fontsize=10)
|
|
document.set_toc([[1, 'Root', 1], [2, 'Child', 1]])
|
|
parsed = parse('outline.pdf', document.tobytes()); document.close()
|
|
repaired, report = analyze(parsed['markdown'], parsed['source'])
|
|
self.assertIn('# Root', repaired)
|
|
self.assertIn('## Child', repaired)
|
|
self.assertIn('Body value 42.', repaired)
|
|
self.assertEqual([h['source'] for h in report['headings']], ['pdf_bookmark', 'pdf_bookmark'])
|