| import json |
| import io |
| from pathlib import Path |
| import tempfile |
| import threading |
| import unittest |
| from unittest.mock import patch |
| from urllib.error import HTTPError |
| from urllib.request import Request, urlopen |
|
|
| from app import Dataset, ReviewError, make_server |
|
|
|
|
| def request_without_socket(dataset, path, body=None, origin='http://127.0.0.1'): |
| """Exercise the real HTTP parser and handler without opening a network port.""" |
| class Connection: |
| def __init__(self, request): |
| self.request = request |
| self.response = bytearray() |
|
|
| def makefile(self, *args): |
| return io.BytesIO(self.request) |
|
|
| def sendall(self, data): |
| self.response.extend(data) |
|
|
| with patch('app.ThreadingHTTPServer') as constructor: |
| server = make_server(dataset, '127.0.0.1', 0) |
| handler = constructor.call_args.args[1] |
| payload = b'' if body is None else json.dumps(body).encode() |
| method = 'GET' if body is None else 'POST' |
| headers = (f'{method} {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nOrigin: {origin}\r\n' |
| f'X-Annotation-Client: ddj-review\r\nContent-Type: application/json\r\n' |
| f'Content-Length: {len(payload)}\r\nConnection: close\r\n\r\n').encode() |
| connection = Connection(headers + payload) |
| with patch.object(handler, 'log_message'): |
| handler(connection, ('127.0.0.1', 10000), server) |
| headers, content = bytes(connection.response).split(b'\r\n\r\n', 1) |
| return {'status': int(headers.split()[1]), 'data': json.loads(content)} |
|
|
|
|
| class AnnotationTest(unittest.TestCase): |
| def setUp(self): |
| self.temp = tempfile.TemporaryDirectory() |
| self.root = Path(self.temp.name) |
| for folder in ['v54', 'v61']: |
| parent = self.root / folder |
| parent.mkdir() |
| for name in ['ABC_source.png', 'ABC_edited.png', 'ABC_result.png', 'ABC_result_v104.png', 'ABC_result_v9.png']: |
| (parent / name).write_bytes(b'fixture image') |
| (self.root / 'v54/NORESULT_source_err.jpg').write_bytes(b'fixture') |
| (self.root / 'v54/ORPHAN_result_v104.png').write_bytes(b'fixture') |
| self.data = Dataset(self.root) |
| self.record = next(r for r in self.data.records.values() if r['folder'] == 'v54' and r['id'] == 'ABC') |
|
|
| def tearDown(self): |
| self.temp.cleanup() |
|
|
| def test_source_grouping_versions_and_missing_results(self): |
| state = self.data.state() |
| self.assertEqual(state['stats'], {'total': 3, 'done': 0, 'rejected': 0, 'pending': 2, 'no_results': 1}) |
| self.assertEqual([x['version'] for x in self.record['results']], ['original', 'v9', 'v104']) |
| self.assertEqual(len({x['key'] for x in state['items']}), 3) |
|
|
| def test_selection_survives_restart_and_stays_in_own_directory(self): |
| self.data.choose(self.record['key'], 'ABC_result_v104.png', 'missing') |
| self.assertEqual((self.root / 'v54/ABC_best.txt').read_text(), 'ABC_result_v104.png\n') |
| self.assertFalse((self.root / 'v61/ABC_best.txt').exists()) |
| self.assertEqual(Dataset(self.root).state()['stats']['done'], 1) |
|
|
| def test_shards_share_model_filter_but_save_in_their_own_directory(self): |
| for model, identity in [('v54', 'ABC123'), ('v54', 'XYZ987'), ('v61', 'ABC123')]: |
| directory = self.root / model / identity[:3] |
| directory.mkdir() |
| for suffix in ('source', 'result'): |
| (directory / f'{identity}_{suffix}.png').write_bytes(b'fixture') |
| self.data.scan() |
| item = next(x for x in self.data.state()['items'] if x['folder'] == 'v54/ABC') |
| self.assertEqual(item['model'], 'v54') |
| self.assertIn('v54%2FABC%2FABC123_source.png', item['source_url']) |
| self.data.choose(item['key'], 'ABC123_result.png', item['revision']) |
| self.assertEqual((self.root / 'v54/ABC/ABC123_best.txt').read_text(), 'ABC123_result.png\n') |
| self.assertFalse((self.root / 'v61/ABC/ABC123_best.txt').exists()) |
| for scan_root in (self.root / 'v54', self.root / 'v54/ABC'): |
| items = Dataset(scan_root).state()['items'] |
| self.assertTrue(all(x['model'] == 'v54' for x in items)) |
|
|
| def test_missing_source_or_result_is_not_saved(self): |
| (self.root / 'v54/ABC_result_v104.png').unlink() |
| with self.assertRaises(ReviewError): |
| self.data.choose(self.record['key'], 'ABC_result_v104.png', 'missing') |
| (self.root / 'v54/ABC_source.png').unlink() |
| with self.assertRaises(ReviewError): |
| self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| self.assertFalse((self.root / 'v54/ABC_best.txt').exists()) |
|
|
| def test_stale_revision_cannot_overwrite_another_selection(self): |
| item = self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| with self.assertRaises(ReviewError) as error: |
| self.data.choose(self.record['key'], 'ABC_result_v104.png', 'missing') |
| self.assertEqual(error.exception.status, 409) |
| self.assertEqual((self.root / 'v54/ABC_best.txt').read_text(), 'ABC_result.png\n') |
| self.data.choose(self.record['key'], None, item['revision'], clear=True) |
| self.assertFalse((self.root / 'v54/ABC_best.txt').exists()) |
|
|
| def test_invalid_old_label_is_pending_and_can_be_replaced(self): |
| (self.root / 'v54/ABC_best.txt').write_text('ABC_result_deleted.png\n') |
| item = self.data.describe(self.record) |
| self.assertTrue(item['invalid_best']) |
| self.assertIsNone(item['best']) |
| self.data.choose(self.record['key'], 'ABC_result_v104.png', item['revision']) |
| self.assertEqual(self.data.state()['stats']['done'], 1) |
|
|
| def test_foreign_files_and_symlink_labels_are_rejected(self): |
| for value in ['../outside.png', '.git/config', '/etc/passwd', 'v54/ABC_best.txt']: |
| with self.assertRaises(ReviewError): |
| self.data.resolve_media(value) |
| target = self.root / 'sentinel.txt' |
| target.write_text('keep') |
| (self.root / 'v54/ABC_best.txt').symlink_to(target) |
| with self.assertRaises(ReviewError): |
| self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| self.assertEqual(target.read_text(), 'keep') |
|
|
| def test_rejection_reason_persists_and_stays_in_own_directory(self): |
| item = self.data.reject(self.record['key'], 'result_unsatisfied', 'missing') |
| rejection = self.root / 'v54/ABC_all_rejected.txt' |
| self.assertEqual(rejection.read_text(), 'result_unsatisfied\n') |
| self.assertFalse((self.root / 'v54/ABC_best.txt').exists()) |
| self.assertFalse((self.root / 'v61/ABC_all_rejected.txt').exists()) |
| self.assertEqual(Dataset(self.root).describe(self.record)['rejection'], 'result_unsatisfied') |
| self.assertEqual(self.data.state()['stats'], {'total': 3, 'done': 1, 'rejected': 1, 'pending': 1, 'no_results': 1}) |
| item = self.data.reject(self.record['key'], 'edited_unsatisfied', item['revision']) |
| self.assertEqual(rejection.read_text(), 'edited_unsatisfied\n') |
| self.assertEqual(item['rejection'], 'edited_unsatisfied') |
|
|
| def test_best_and_rejection_replace_each_other_and_can_be_cleared(self): |
| item = self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| item = self.data.reject(self.record['key'], 'edited_unsatisfied', item['revision']) |
| self.assertFalse((self.root / 'v54/ABC_best.txt').exists()) |
| self.assertIsNone(item['best']) |
| item = self.data.choose(self.record['key'], 'ABC_result_v104.png', item['revision']) |
| self.assertFalse((self.root / 'v54/ABC_all_rejected.txt').exists()) |
| self.assertIsNone(item['rejection']) |
| item = self.data.reject(self.record['key'], 'result_unsatisfied', item['revision']) |
| item = self.data.choose(self.record['key'], None, item['revision'], clear=True) |
| self.assertEqual(item['revision'], 'missing') |
| self.assertFalse((self.root / 'v54/ABC_best.txt').exists()) |
| self.assertFalse((self.root / 'v54/ABC_all_rejected.txt').exists()) |
|
|
| def test_stale_best_or_rejection_cannot_overwrite_a_new_decision(self): |
| first = self.data.reject(self.record['key'], 'result_unsatisfied', 'missing') |
| with self.assertRaises(ReviewError): |
| self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| second = self.data.reject(self.record['key'], 'edited_unsatisfied', first['revision']) |
| with self.assertRaises(ReviewError): |
| self.data.choose(self.record['key'], None, first['revision'], clear=True) |
| self.assertEqual(self.data.describe(self.record)['revision'], second['revision']) |
|
|
| def test_invalid_or_missing_rejection_target_does_not_change_annotations(self): |
| item = self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| for reason in ['wrong_reason', '../file', None, []]: |
| with self.assertRaises(ReviewError): |
| self.data.reject(self.record['key'], reason, item['revision']) |
| (self.root / 'v54/ABC_edited.png').unlink() |
| with self.assertRaises(ReviewError): |
| self.data.reject(self.record['key'], 'edited_unsatisfied', item['revision']) |
| self.assertEqual((self.root / 'v54/ABC_best.txt').read_text(), 'ABC_result.png\n') |
| empty = next(r for r in self.data.records.values() if r['id'] == 'NORESULT') |
| with self.assertRaises(ReviewError): |
| self.data.reject(empty['key'], 'result_unsatisfied', 'missing') |
| (self.root / 'v54/ABC_source.png').unlink() |
| with self.assertRaises(ReviewError): |
| self.data.reject(self.record['key'], 'result_unsatisfied', item['revision']) |
|
|
| def test_rejection_symlink_and_failed_write_preserve_existing_choice(self): |
| item = self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| with patch('app.os.replace', side_effect=OSError('simulated full disk')): |
| with self.assertRaises(OSError): |
| self.data.reject(self.record['key'], 'result_unsatisfied', item['revision']) |
| self.assertEqual((self.root / 'v54/ABC_best.txt').read_text(), 'ABC_result.png\n') |
| self.assertEqual(list((self.root / 'v54').glob('*.tmp')), []) |
| target = self.root / 'sentinel.txt' |
| target.write_text('keep') |
| (self.root / 'v54/ABC_all_rejected.txt').symlink_to(target) |
| with self.assertRaises(ReviewError): |
| self.data.reject(self.record['key'], 'result_unsatisfied', item['revision']) |
| self.assertEqual(target.read_text(), 'keep') |
|
|
| def test_conflicting_or_invalid_labels_can_be_repaired(self): |
| self.data.choose(self.record['key'], 'ABC_result.png', 'missing') |
| (self.root / 'v54/ABC_all_rejected.txt').write_text('result_unsatisfied\n') |
| item = self.data.describe(self.record) |
| self.assertTrue(item['annotation_conflict']) |
| self.assertIsNone(item['best']) |
| self.assertIsNone(item['rejection']) |
| self.data.choose(self.record['key'], 'ABC_result_v104.png', item['revision']) |
| self.assertFalse((self.root / 'v54/ABC_all_rejected.txt').exists()) |
| (self.root / 'v54/ABC_best.txt').unlink() |
| (self.root / 'v54/ABC_all_rejected.txt').write_text('unknown_reason\n') |
| item = self.data.describe(self.record) |
| self.assertTrue(item['invalid_rejection']) |
| self.data.reject(self.record['key'], 'edited_unsatisfied', item['revision']) |
| self.assertEqual(self.data.describe(self.record)['rejection'], 'edited_unsatisfied') |
|
|
| def test_http_save_and_cross_site_write_rejection(self): |
| server = make_server(self.data, '127.0.0.1', 0) |
| thread = threading.Thread(target=server.serve_forever, daemon=True) |
| thread.start() |
| base = f'http://127.0.0.1:{server.server_port}' |
| payload = json.dumps({'key': self.record['key'], 'result': 'ABC_result_v104.png', 'revision': 'missing'}).encode() |
| try: |
| with urlopen(base + '/api/state') as response: |
| self.assertEqual(json.load(response)['stats']['pending'], 2) |
| headers = {'Content-Type': 'application/json', 'X-Annotation-Client': 'ddj-review', 'Origin': 'https://unrelated.invalid'} |
| with self.assertRaises(HTTPError) as error: |
| urlopen(Request(base + '/api/choose', data=payload, headers=headers)) |
| self.assertEqual(error.exception.code, 403) |
| self.assertFalse((self.root / 'v54/ABC_best.txt').exists()) |
| headers['Origin'] = base |
| with urlopen(Request(base + '/api/choose', data=payload, headers=headers)) as response: |
| chosen = json.load(response)['item'] |
| self.assertEqual(chosen['best'], 'ABC_result_v104.png') |
| payload = json.dumps({'key': self.record['key'], 'reason': 'edited_unsatisfied', 'revision': chosen['revision']}).encode() |
| headers['Origin'] = 'https://unrelated.invalid' |
| with self.assertRaises(HTTPError) as error: |
| urlopen(Request(base + '/api/reject', data=payload, headers=headers)) |
| self.assertEqual(error.exception.code, 403) |
| headers['Origin'] = base |
| with urlopen(Request(base + '/api/reject', data=payload, headers=headers)) as response: |
| self.assertEqual(json.load(response)['item']['rejection'], 'edited_unsatisfied') |
| self.assertEqual((self.root / 'v54/ABC_all_rejected.txt').read_text(), 'edited_unsatisfied\n') |
| self.assertFalse((self.root / 'v54/ABC_best.txt').exists()) |
| finally: |
| server.shutdown() |
| server.server_close() |
| thread.join() |
|
|
| def test_http_rejection_and_clear_without_network(self): |
| state = request_without_socket(self.data, '/api/state') |
| self.assertEqual(state['status'], 200) |
| payload = {'key': self.record['key'], 'reason': 'result_unsatisfied', 'revision': 'missing'} |
| denied = request_without_socket(self.data, '/api/reject', payload, origin='https://unrelated.invalid') |
| self.assertEqual(denied['status'], 403) |
| rejected = request_without_socket(self.data, '/api/reject', payload) |
| self.assertEqual(rejected['status'], 200) |
| self.assertEqual(rejected['data']['item']['rejection'], 'result_unsatisfied') |
| self.assertEqual(request_without_socket(self.data, '/api/reject', payload)['status'], 409) |
| payload['revision'] = rejected['data']['item']['revision'] |
| payload['reason'] = 'edited_unsatisfied' |
| rejected = request_without_socket(self.data, '/api/reject', payload) |
| self.assertEqual(rejected['status'], 200) |
| self.assertEqual((self.root / 'v54/ABC_all_rejected.txt').read_text(), 'edited_unsatisfied\n') |
| payload = {'key': self.record['key'], 'revision': rejected['data']['item']['revision']} |
| cleared = request_without_socket(self.data, '/api/clear', payload) |
| self.assertEqual(cleared['status'], 200) |
| self.assertEqual(cleared['data']['item']['revision'], 'missing') |
| self.assertFalse((self.root / 'v54/ABC_all_rejected.txt').exists()) |
|
|
|
|
| if __name__ == '__main__': |
| unittest.main() |
|
|
