feat(seo): atomic directive fencing and transactional blog publication
Deploy Canina / deploy (push) Successful in 4m45s

This commit is contained in:
Canina Automation committed 2026-10-28 08:02:30 +00:00
1 parent 0a156fd7b4
commit fb1deadbbc
10 files changed
+353 -187

No files matched your search

+62 -139
View File
@@ -2,170 +2,93 @@ 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.stale = False
self.fail_link = False
self.created = []
self.ambiguous = False
def __call__(self, method, path, body=None):
self.events.append((method, path, body))
if method == 'POST':
if not path.endswith('/publication'):
return self.row.copy()
if method == 'GET':
return self.row.copy()
if self.stale or (body.get('blogId') and self.fail_link):
if body['expectedVersion'] != self.row['version'] or body['feedbackVersion'] != self.row['feedbackVersion'] or self.row.get('blogId'):
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()
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)
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'}
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):
self.c.publish('day-run', packet, draft, None, self.publish)
receipt = self.review(packet, draft)
receipt['draftHash'] = 'wrong'
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):
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
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):
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')
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):
self.c.publish('day-run', packet, {}, None, ambiguous)
restarted = Consumer(self.c.path, self.api)
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):
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
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('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()
self.c.publish('run', dict(p, ceoFeedback='tampered'), {}, None, lambda d: d)
other = Consumer(self.c.path, self.api)
def nested(draft):
def preflight(d):
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)
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()