95 lines
4.5 KiB
Python
95 lines
4.5 KiB
Python
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from consumer import Consumer, Blocked, digest
|
|
from daily_publisher import run_new
|
|
|
|
class API:
|
|
def __init__(self):
|
|
self.row = dict(id='finding', version=0, feedbackVersion=0, ceoFeedback=None)
|
|
self.events = []
|
|
self.created = []
|
|
self.ambiguous = False
|
|
def __call__(self, method, path, body=None):
|
|
self.events.append((method, path, body))
|
|
if not path.endswith('/publication'):
|
|
return self.row.copy()
|
|
if body['expectedVersion'] != self.row['version'] or body['feedbackVersion'] != self.row['feedbackVersion'] or self.row.get('blogId'):
|
|
raise Blocked('409 stale')
|
|
self.created.append(body['blog'])
|
|
self.row.update(version=self.row['version'] + 1, blogId='blog-id', actionId=body['actionId'])
|
|
if self.ambiguous:
|
|
raise TimeoutError('committed response lost')
|
|
return dict(blog={'id': 'blog-id'}, finding=self.row.copy(), consumedFeedbackVersion=body['feedbackVersion'])
|
|
|
|
class ConsumerTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.api = API()
|
|
self.c = Consumer(Path(self.tmp.name) / 'journal.db', self.api)
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
def receipt(self, p, d, *args):
|
|
return dict(reviewer='independent', evidence='immutable://receipt', directiveHash=digest(p), draftHash=digest(d))
|
|
def test_entrypoint_receives_directive_then_atomic_publication_idempotent(self):
|
|
self.api.row.update(version=1, feedbackVersion=1, ceoFeedback='cats')
|
|
def draft(p):
|
|
self.assertEqual(p['ceoFeedback'], 'cats')
|
|
return {'content': 'cats'}
|
|
self.assertEqual(run_new(self.c, 'run', {}, draft, self.receipt, lambda d: d), 'blog-id')
|
|
import json
|
|
p = json.loads(self.c.row('run')['packet'])
|
|
self.assertEqual(self.c.publish('run', p, {}, None, lambda d: d), 'blog-id')
|
|
self.assertEqual(len(self.api.created), 1)
|
|
self.assertFalse(any(e[0] == 'PATCH' for e in self.api.events))
|
|
def test_feedback_between_preflight_and_create_blocks_blog(self):
|
|
def preflight(d):
|
|
self.api.row.update(version=1, feedbackVersion=1, ceoFeedback='late')
|
|
return d
|
|
with self.assertRaises(Blocked):
|
|
run_new(self.c, 'run', {}, lambda p: {}, self.receipt, preflight)
|
|
self.assertEqual(self.api.created, [])
|
|
def test_non_payload_legacy_callback_fails_closed(self):
|
|
with self.assertRaises(Blocked):
|
|
run_new(self.c, 'run', {}, lambda p: {}, self.receipt, lambda d: 'blog-id')
|
|
self.assertEqual(self.api.created, [])
|
|
def test_preflight_cannot_mutate_reviewed_payload(self):
|
|
def mutate(d):
|
|
d['content'] = 'unreviewed'
|
|
return d
|
|
with self.assertRaises(Blocked):
|
|
run_new(self.c, 'run', {}, lambda p: {'content': 'reviewed'}, self.receipt, mutate)
|
|
self.assertEqual(self.api.created, [])
|
|
def test_review_exact_hash_required(self):
|
|
self.api.row.update(ceoFeedback='cats')
|
|
p = self.c.prepare('run', {})
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('run', p, {}, None, lambda d: d)
|
|
r = self.receipt(p, {})
|
|
r['draftHash'] = 'bad'
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('run', p, {}, r, lambda d: d)
|
|
def test_ambiguous_response_reconciles_read_only_even_after_new_feedback(self):
|
|
self.api.ambiguous = True
|
|
with self.assertRaises(TimeoutError):
|
|
run_new(self.c, 'run', {}, lambda p: {}, self.receipt, lambda d: d)
|
|
self.api.row.update(version=2, feedbackVersion=1, ceoFeedback='next action')
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('run', self.c.prepare('run', {}), {}, None, lambda d: d)
|
|
self.assertEqual(self.c.reconcile_link('run'), 'blog-id')
|
|
self.assertEqual(len(self.api.created), 1)
|
|
def test_packet_tampering_and_parallel_consumers_blocked(self):
|
|
p = self.c.prepare('run', {})
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('run', dict(p, ceoFeedback='tampered'), {}, None, lambda d: d)
|
|
other = Consumer(self.c.path, self.api)
|
|
def preflight(d):
|
|
with self.assertRaises(Blocked):
|
|
other.publish('run', p, d, None, lambda d: d)
|
|
return d
|
|
self.c.publish('run', p, {}, None, preflight)
|
|
self.assertEqual(len(self.api.created), 1)
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|