172 lines
6.9 KiB
Python
172 lines
6.9 KiB
Python
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from consumer import Consumer, Blocked, digest
|
|
|
|
|
|
class API:
|
|
def __init__(self):
|
|
self.row = dict(id='finding', version=0, feedbackVersion=0, ceoFeedback=None)
|
|
self.events = []
|
|
self.stale = False
|
|
self.fail_link = False
|
|
|
|
def __call__(self, method, path, body=None):
|
|
self.events.append((method, path, body))
|
|
if method == 'POST':
|
|
return self.row.copy()
|
|
if method == 'GET':
|
|
return self.row.copy()
|
|
if self.stale or (body.get('blogId') and self.fail_link):
|
|
raise Blocked('409 stale')
|
|
assert body['expectedVersion'] == self.row['version']
|
|
assert body['feedbackVersion'] == self.row['feedbackVersion']
|
|
self.row.update({k: v for k, v in body.items() if k not in ('expectedVersion', 'feedbackVersion')})
|
|
self.row['version'] += 1
|
|
return self.row.copy()
|
|
|
|
|
|
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)
|
|
self.created = []
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def publish(self, draft):
|
|
self.created.append(draft)
|
|
return 'blog-id'
|
|
|
|
def prepare(self):
|
|
return self.c.prepare('day-run', {'title': 'research'})
|
|
|
|
def review(self, packet, draft):
|
|
return dict(reviewer='independent-seo', directiveHash=digest(packet), draftHash=digest(draft), evidence='immutable://review-receipt')
|
|
|
|
def test_research_before_draft_then_claim_create_link_idempotent(self):
|
|
packet = self.prepare()
|
|
draft = {'html': 'reviewed'}
|
|
result = self.c.publish('day-run', packet, draft, None, self.publish)
|
|
self.assertEqual(result, 'blog-id')
|
|
self.assertEqual(self.c.publish('day-run', packet, draft, None, self.publish), result)
|
|
self.assertEqual(len(self.created), 1)
|
|
events = self.api.events
|
|
self.assertEqual(events[0][0], 'POST')
|
|
self.assertEqual(events[-1][2]['blogId'], 'blog-id')
|
|
self.assertEqual([e for e in events if e[0] == 'PATCH'][0][2]['feedbackVersion'], 0)
|
|
|
|
def test_directive_passed_and_requires_exact_review(self):
|
|
self.api.row.update(version=3, feedbackVersion=2, ceoFeedback='Focus on cats')
|
|
packet = self.prepare()
|
|
self.assertEqual(packet['ceoFeedback'], 'Focus on cats')
|
|
draft = {'html': 'cats'}
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('day-run', packet, draft, None, self.publish)
|
|
receipt = self.review(packet, draft)
|
|
receipt['draftHash'] = 'wrong'
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('day-run', packet, draft, receipt, self.publish)
|
|
self.c.publish('day-run', packet, draft, self.review(packet, draft), self.publish)
|
|
self.assertEqual(len(self.created), 1)
|
|
|
|
def test_stale_claim_never_calls_publisher(self):
|
|
packet = self.prepare()
|
|
self.api.stale = True
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('day-run', packet, {}, None, self.publish)
|
|
self.assertEqual(self.created, [])
|
|
|
|
def test_ambiguous_publish_blocks_restart(self):
|
|
packet = self.prepare()
|
|
def ambiguous(draft):
|
|
self.created.append(draft)
|
|
raise TimeoutError('unknown write outcome')
|
|
with self.assertRaises(TimeoutError):
|
|
self.c.publish('day-run', packet, {}, None, ambiguous)
|
|
restarted = Consumer(self.c.path, self.api)
|
|
with self.assertRaises(Blocked):
|
|
restarted.publish('day-run', packet, {}, None, self.publish)
|
|
self.assertEqual(len(self.created), 1)
|
|
|
|
def test_link_failure_can_retry_link_only(self):
|
|
packet = self.prepare()
|
|
self.api.fail_link = True
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('day-run', packet, {}, None, self.publish)
|
|
self.api.fail_link = False
|
|
self.c.reconcile_link('day-run')
|
|
self.assertEqual(len(self.created), 1)
|
|
|
|
def test_research_post_ambiguity_never_reposted(self):
|
|
def fail(*args):
|
|
raise TimeoutError('unknown')
|
|
c = Consumer(self.c.path, fail)
|
|
with self.assertRaises(TimeoutError):
|
|
c.prepare('run', {})
|
|
with self.assertRaises(Blocked):
|
|
self.c.prepare('run', {})
|
|
self.assertEqual(self.api.events, [])
|
|
|
|
def test_packet_tampering_rejected(self):
|
|
packet = self.prepare()
|
|
packet['ceoFeedback'] = ''
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('day-run', packet, {}, None, self.publish)
|
|
|
|
def test_actual_entrypoint_delivers_directive_before_create(self):
|
|
from daily_publisher import run_new
|
|
self.api.row.update(version=1, feedbackVersion=1, ceoFeedback='cats only')
|
|
order = []
|
|
def draft(packet):
|
|
self.assertEqual(self.api.events[0][0], 'POST')
|
|
self.assertEqual(packet['ceoFeedback'], 'cats only')
|
|
order.append('draft')
|
|
return {'html': 'cats'}
|
|
def review(packet, article, directive_hash, draft_hash):
|
|
order.append('review')
|
|
return self.review(packet, article)
|
|
def create(article):
|
|
order.append('create')
|
|
return self.publish(article)
|
|
self.assertEqual(run_new(self.c, 'entry', {}, draft, review, create), 'blog-id')
|
|
self.assertEqual(order, ['draft', 'review', 'create'])
|
|
|
|
def test_feedback_edit_during_draft_rejects_action_and_create(self):
|
|
from daily_publisher import run_new
|
|
def draft(packet):
|
|
self.api.row.update(version=1, feedbackVersion=1, ceoFeedback='new instruction')
|
|
self.api.stale = True
|
|
return {}
|
|
with self.assertRaises(Blocked):
|
|
run_new(self.c, 'entry', {}, draft, lambda *args: None, self.publish)
|
|
self.assertEqual(self.created, [])
|
|
|
|
def test_feedback_after_claim_retains_created_identity_no_second_create(self):
|
|
packet = self.prepare()
|
|
def create(draft):
|
|
self.api.row.update(version=2, feedbackVersion=1, ceoFeedback='late')
|
|
return self.publish(draft)
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('day-run', packet, {}, None, create)
|
|
self.assertEqual(self.c.row('day-run')['blog'], 'blog-id')
|
|
with self.assertRaises(Blocked):
|
|
self.c.publish('day-run', packet, {}, None, self.publish)
|
|
self.assertEqual(len(self.created), 1)
|
|
|
|
def test_overlapping_consumers_only_one_publish(self):
|
|
packet = self.prepare()
|
|
other = Consumer(self.c.path, self.api)
|
|
def nested(draft):
|
|
with self.assertRaises(Blocked):
|
|
other.publish('day-run', packet, draft, None, self.publish)
|
|
return self.publish(draft)
|
|
self.c.publish('day-run', packet, {}, None, nested)
|
|
self.assertEqual(len(self.created), 1)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|