| import errno |
| import importlib.util |
| import os |
| from pathlib import Path |
| import tempfile |
| import unittest |
| from unittest import mock |
|
|
| SPEC=importlib.util.spec_from_file_location('pagefs',Path(__file__).resolve().parents[1]/'pagefs.py') |
| m=importlib.util.module_from_spec(SPEC);SPEC.loader.exec_module(m) |
|
|
| class EngineTests(unittest.TestCase): |
| def setUp(self): |
| self.tmp=tempfile.TemporaryDirectory();self.path=Path(self.tmp.name)/'image' |
| def tearDown(self):self.tmp.cleanup() |
| def create(self,files=None,pool=512):return m.PageStore.create(self.path,initial_files=files,pool_blocks=pool) |
| def damage(self,offset,n): |
| with open(self.path,'r+b',buffering=0) as f:f.seek(offset);f.write(bytes(n));os.fsync(f.fileno()) |
| def test_genesis_and_fixed_capacity(self): |
| with self.create({'/a':b'x'}) as s: |
| self.assertEqual(s.get('/a'),b'x');self.assertEqual(s.epoch,0) |
| self.assertEqual(os.stat(self.path).st_size,m.POOL_START+512*m.BLOCK_SIZE) |
| self.assertEqual(len(s._live_blocks)+len(s._free),s.pool_blocks) |
| def test_transaction_one_force_two_writes(self): |
| with self.create() as s: |
| s.reset_stats();self.assertEqual(s.transact({'/a':b'x','/b':b'y'},'tx'),1) |
| self.assertEqual(s.stats['write_calls'],2);self.assertEqual(s.stats['fsync_calls'],1) |
| self.assertEqual(s.stats['page_allocations'],0) |
| def test_multi_path_delete_and_reopen(self): |
| with self.create({'/a':b'old','/b':b'b'}) as s: |
| s.transact({'/a':b'new','/b':None,'/missing':None},'one') |
| with m.PageStore(self.path,writable=False) as s: |
| self.assertEqual(s.files(),['/a']);self.assertEqual(s.get('/a'),b'new');self.assertEqual(s.query('one')['epoch'],1) |
| def test_retry_is_no_io_and_survives_checkpoint(self): |
| with self.create() as s: |
| s.transact({'/a':b'x'},'same');s.checkpoint();s.reset_stats() |
| self.assertEqual(s.transact({'/a':b'x'},'same'),1);self.assertEqual(s.stats['write_calls'],0) |
| with self.assertRaises(m.TransactionConflict):s.transact({'/a':b'y'},'same') |
| with m.PageStore(self.path) as s:self.assertEqual(s.transact({'/a':b'x'},'same'),1) |
| def test_unicode_escaped_keys(self): |
| data={'/雪/"name\n':b'\x00\xff','/emoji😀':b''} |
| with self.create(data) as s:s.checkpoint() |
| with m.PageStore(self.path,writable=False) as s: |
| for key,value in data.items():self.assertEqual(s.get(key),value) |
| def test_invalid_creation_inputs_have_no_file(self): |
| for files in ({'/a':bytes(m.MAX_CAPSULE+1)},{'relative':b'a'},{'/a':'str'}): |
| with self.assertRaises((ValueError,TypeError)):self.create(files) |
| self.assertFalse(self.path.exists()) |
| def test_overescaped_path_rejected_before_ack(self): |
| with self.create() as s: |
| s.reset_stats() |
| with self.assertRaises(ValueError):s.transact({'/'+chr(1)*1000:b'x'},'bad') |
| self.assertEqual(s.stats['write_calls'],0) |
| def test_volatile_caches_match_exact_live_identities(self): |
| with self.create(pool=256) as s: |
| for i in range(60): |
| s.transact({'/a':str(i).encode()},f't{i}');s.checkpoint() |
| self.assertEqual(set(s._cache),set(s._refs)) |
| self.assertEqual(set(s._graph_cache),set(s._refs)) |
| def test_initial_largest_value(self): |
| raw=bytes(range(256))*(m.MAX_CAPSULE//256)+bytes(m.MAX_CAPSULE%256) |
| with self.create({'/large':raw}):pass |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/large'),raw) |
| def test_capsule_size_rejected_without_io(self): |
| with self.create() as s: |
| s.reset_stats() |
| with self.assertRaises(ValueError):s.transact({'/a':bytes(m.MAX_CAPSULE)},'large') |
| self.assertEqual(s.stats['write_calls'],0);self.assertFalse(s.fenced) |
| def test_inline_boundary_and_blob(self): |
| for size in (0,1,255,256,257,m.PAGE_PAYLOAD,m.PAGE_PAYLOAD+1,30000): |
| with self.subTest(size=size): |
| with self.create() as s: |
| value=bytes([size%256])*size;s.transact({'/a':value},'one');s.checkpoint() |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),value) |
| self.path.unlink() |
| def test_tree_splits_and_delete_preserve_neighbors(self): |
| files={f'/f{i}':bytes([i%256])*128 for i in range(300)} |
| with self.create(files,pool=1024) as s: |
| s.transact({'/f155':None,'/f156':b'changed'},'one');s.checkpoint() |
| files.pop('/f155');files['/f156']=b'changed' |
| with m.PageStore(self.path,writable=False) as s: |
| self.assertEqual(s.files(),sorted(files)) |
| for key,value in files.items():self.assertEqual(s.get(key),value) |
| def test_unchanged_subtree_reused(self): |
| with self.create({f'/f{i}':bytes(128) for i in range(300)},pool=1024) as s: |
| old=m.unpack_json(s._read_object(s.files_root,m.K_TRIE))['children'] |
| s.transact({'/f1':b'new'},'one');s.checkpoint() |
| new=m.unpack_json(s._read_object(s.files_root,m.K_TRIE))['children'] |
| nib=m.hash_key('/f1')[0] |
| for key in old: |
| if key!=nib:self.assertEqual(old[key],new[key]) |
| def test_cold_blobs_not_redecoded_during_checkpoint(self): |
| with self.create({f'/f{i}':bytes([i])*4000 for i in range(32)},pool=1024) as s: |
| s.transact({'/new':b'x'},'one') |
| original=m.unb64;calls=[] |
| def counted(value):calls.append(len(value));return original(value) |
| with mock.patch.object(m,'unb64',counted):s.checkpoint() |
| self.assertLess(max(calls,default=0),100) |
| def test_automatic_pressure_checkpoint(self): |
| with self.create() as s: |
| for i in range(65):s.transact({'/a':str(i).encode()},f't{i}') |
| self.assertEqual(s.checkpoint_epoch,64);self.assertEqual(len(s.active),1) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.epoch,65);self.assertEqual(s.get('/a'),b'64') |
| def test_reuse_keeps_file_bounded(self): |
| with self.create(pool=256) as s: |
| size=os.stat(self.path).st_size |
| for i in range(300): |
| s.transact({'/a':bytes([i%256])*1000},f't{i}') |
| if i%20==19:s.checkpoint() |
| self.assertGreater(s.stats['reclaimed_blocks'],256) |
| self.assertEqual(os.stat(self.path).st_size,size) |
| self.assertFalse(set(s._free)&s._live_blocks) |
| self.assertEqual(len(set(s._free))+len(s._live_blocks),256) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),bytes([299%256])*1000) |
| def test_empty_checkpoint_and_reopen(self): |
| with self.create() as s: |
| for _ in range(5):self.assertEqual(s.checkpoint(),0) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.epoch,0) |
| def test_read_only_cannot_mutate(self): |
| with self.create():pass |
| with m.PageStore(self.path,writable=False) as s: |
| with self.assertRaises(m.WriterFenced):s.transact({'/a':b'a'},'x') |
| with self.assertRaises(m.WriterFenced):s.checkpoint() |
| def test_single_pool_mirror_recovery_and_repair(self): |
| with self.create({'/a':b'x'}) as s:root=list(s.catalog_desc) |
| self.damage(m.block_offset(root[0]),m.BLOCK_SIZE) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'x') |
| with m.PageStore(self.path) as s:self.assertGreater(s.stats['write_calls'],0) |
| self.damage(m.block_offset(root[1]),m.BLOCK_SIZE) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'x') |
| def test_both_newest_root_mirrors_block_fallback(self): |
| with self.create({'/a':b'old'}) as s: |
| s.transact({'/a':b'new'},'one');s.checkpoint();root=list(s.catalog_desc) |
| for index in root[:2]:self.damage(m.block_offset(index),m.BLOCK_SIZE) |
| with self.assertRaises(m.RecoveryBlocked):m.PageStore(self.path,writable=False) |
| def test_capsule_mirror_repair(self): |
| with self.create() as s:s.transact({'/a':b'x'},'one') |
| self.damage(m.capsule_offset(1,0),m.SPAN) |
| with m.PageStore(self.path) as s:self.assertEqual(s.get('/a'),b'x');self.assertGreater(s.stats['write_calls'],0) |
| self.damage(m.capsule_offset(1,1),m.SPAN) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'x') |
| def test_valid_header_without_payload_blocks(self): |
| with self.create() as s:s.transact({'/a':b'x'},'one') |
| for replica in range(2):self.damage(m.capsule_offset(1,replica)+m.HEADER.size,400) |
| with self.assertRaises(m.RecoveryBlocked):m.PageStore(self.path,writable=False) |
| def test_single_latest_seal_is_normalized(self): |
| with self.create() as s:s.transact({'/a':b'x'},'one');s.checkpoint();generation=s.generation |
| pair=range((generation%2)*2,(generation%2)*2+2) |
| self.damage(m.SEAL_OFFSETS[list(pair)[0]],m.SECTOR) |
| with m.PageStore(self.path) as s:self.assertEqual(len(s._selected_valid_slots),2) |
| def test_dependency_failure_fences_and_preserves_ack(self): |
| with self.create({'/a':b'old'}) as s: |
| s.transact({'/a':b'new'},'one') |
| with mock.patch.object(s,'_sync',side_effect=OSError('force failed')): |
| with self.assertRaises(OSError):s.checkpoint() |
| self.assertTrue(s.fenced) |
| with self.assertRaises(m.WriterFenced):s.get('/a') |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'new');self.assertEqual(s.query('one')['epoch'],1) |
| def test_publication_failure_fences_and_reopens(self): |
| with self.create() as s: |
| s.transact({'/a':b'x'},'one');original=s._pwrite |
| def fail_seals(raw,off): |
| if off in m.SEAL_OFFSETS:raise OSError('seal failed') |
| original(raw,off) |
| with mock.patch.object(s,'_pwrite',fail_seals): |
| with self.assertRaises(OSError):s.checkpoint() |
| self.assertTrue(s.fenced) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'x') |
| def test_enospc_offer_rejected_before_ack(self): |
| with self.create(pool=16) as s: |
| s.reset_stats();before=self.path.read_bytes() |
| with self.assertRaises(m.AdmissionRejected) as caught:s.transact({'/a':bytes(16000)},'not-ack') |
| self.assertEqual(caught.exception.errno,errno.ENOSPC);self.assertFalse(s.fenced) |
| self.assertEqual(s.epoch,0);self.assertIsNone(s.query('not-ack')) |
| self.assertEqual(s.stats['write_calls'],0);self.assertEqual(before,self.path.read_bytes()) |
| s.transact({'/a':b'fits'},'ack');s.checkpoint() |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'fits');self.assertIsNotNone(s.query('ack')) |
| def test_transaction_adoption_exception_fences(self): |
| with self.create() as s: |
| with mock.patch.object(s,'_apply',side_effect=RuntimeError('RAM failure')): |
| with self.assertRaises(RuntimeError):s.transact({'/a':b'x'},'one') |
| self.assertTrue(s.fenced) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'x') |
| def test_minimum_epoch(self): |
| with self.create():pass |
| with self.assertRaises(m.RecoveryBlocked):m.PageStore(self.path,writable=False,minimum_epoch=1) |
| def test_exclusive_writer(self): |
| with self.create(): |
| with self.assertRaises(BlockingIOError):m.PageStore(self.path) |
| def test_descriptor_future_birth_rejected(self): |
| with self.create({'/a':b'x'}) as s: |
| root=list(s.catalog_desc);root[2]+=1 |
| with self.assertRaises(m.InvalidImage):s._scan_graph(root) |
| def test_generation_exhaustion_no_io(self): |
| with self.create() as s: |
| s.generation=m.MAX_U64;s.reset_stats() |
| with self.assertRaises(m.StoreError):s.checkpoint() |
| self.assertEqual(s.stats['write_calls'],0) |
| def test_checkpoint_avoids_full_scan_and_pool_rebuild(self): |
| with self.create({f'/f{i}':bytes(128) for i in range(500)},pool=1024) as s: |
| s.transact({'/f1':b'changed'},'one');s.reset_stats();s.checkpoint() |
| self.assertEqual(s.stats['full_graph_scans'],0) |
| self.assertEqual(s.stats['pool_rebuilds'],0) |
| self.assertEqual(s.stats['incremental_validations'],1) |
| self.assertLess(s.stats['graph_nodes_validated'],20) |
| self.assertLess(s.stats['refcount_steps'],100) |
| def test_incremental_refcounts_equal_independent_full_graph(self): |
| with self.create({f'/f{i}':bytes(128) for i in range(100)},pool=512) as s: |
| for i in range(80): |
| s.transact({f'/f{i%100}':None if i%3==0 else str(i).encode()},f't{i}') |
| if i%8==7: |
| s.checkpoint() |
| _,blocks,_,_=s._scan_graph(s.catalog_desc) |
| self.assertEqual(blocks,s._live_blocks) |
| self.assertEqual(set(s._refs),set(s._graph_cache)) |
| self.assertTrue(all(count==1 for count in s._refs.values())) |
| self.assertEqual(set(s._free),set(range(s.pool_blocks))-blocks) |
| def test_candidate_and_selected_roots_pinned_before_publication(self): |
| with self.create({'/a':bytes(8000)},pool=256) as s: |
| old=set(s._live_blocks);s.transact({'/a':b'new'},'one') |
| original=s._sync;calls=[] |
| def observe(): |
| calls.append(set(s._live_blocks));self.assertTrue(old<=s._live_blocks) |
| return original() |
| with mock.patch.object(s,'_sync',observe):s.checkpoint() |
| self.assertEqual(len(calls),2);self.assertGreater(len(calls[0]),len(s._live_blocks)) |
| def test_unreachable_reserved_allocation_is_released_after_publication(self): |
| with self.create(pool=128) as s: |
| s._writing_generation=s.generation+1 |
| orphan=s._alloc_object(m.K_DATA,b'orphan');s.checkpoint() |
| self.assertNotIn(tuple(orphan),s._pending);self.assertNotIn(tuple(orphan),s._cache) |
| self.assertTrue(set(orphan[:2])<=set(s._free)) |
| def test_reference_metadata_exception_fences_after_durable_publication(self): |
| with self.create() as s: |
| s.transact({'/a':b'x'},'one') |
| with mock.patch.object(s,'_release',side_effect=RuntimeError('RAM reference failure')): |
| with self.assertRaises(RuntimeError):s.checkpoint() |
| self.assertTrue(s.fenced) |
| with m.PageStore(self.path,writable=False) as s:self.assertEqual(s.get('/a'),b'x') |
| def test_unchanged_subtree_family_context_rejected(self): |
| with self.create({'/a':b'old'}) as s: |
| old_files=s.files_root;original=m.PageStore._update_tree |
| def wrong_family(instance,desc,family,changes,depth=0): |
| return old_files if family=='tokens' else original(instance,desc,family,changes,depth) |
| s.reset_stats() |
| s.transact({'/a':b'new'},'bad');s.reset_stats() |
| with mock.patch.object(m.PageStore,'_update_tree',wrong_family): |
| with self.assertRaises(m.InvalidImage):s.checkpoint_plan() |
| self.assertEqual(s.stats['write_calls'],0);self.assertEqual(s.epoch,1) |
| self.assertEqual(s.get('/a'),b'new') |
| def test_unchanged_blob_cannot_alias_another_file_owner(self): |
| with self.create({'/a':bytes(8000)}) as s: |
| value=m.unpack_json(s._read_object(s.files_root,m.K_TRIE))['entries']['/a'];s.reset_stats() |
| s.transact({'/b':b'offer'},'bad');s.reset_stats() |
| with mock.patch.object(m.PageStore,'_file_value',return_value=value): |
| with self.assertRaises(m.InvalidImage):s.checkpoint_plan() |
| self.assertEqual(s.stats['write_calls'],0);self.assertEqual(s.query('bad')['epoch'],1) |
| def test_nonlive_stale_object_cannot_be_resurrected(self): |
| with self.create({'/a':b'old'}) as s: |
| stale=s.files_root;s.transact({'/a':b'new'},'one');s.checkpoint() |
| self.assertNotIn(tuple(stale),s._refs);original=m.PageStore._update_tree |
| def stale_files(instance,desc,family,changes,depth=0): |
| return stale if family=='files' else original(instance,desc,family,changes,depth) |
| s.reset_stats() |
| s.transact({'/a':b'latest'},'two');s.reset_stats() |
| with mock.patch.object(m.PageStore,'_update_tree',stale_files): |
| with self.assertRaises(m.InvalidImage):s.checkpoint_plan() |
| self.assertEqual(s.stats['write_calls'],0);self.assertEqual(s.get('/a'),b'latest') |
| def test_recovery_builds_references_once(self): |
| with self.create({'/a':bytes(8000)}) as s:s.transact({'/a':b'x'},'one');s.checkpoint() |
| with m.PageStore(self.path) as s: |
| self.assertEqual(s.stats['full_graph_scans'],1);self.assertEqual(s.stats['pool_rebuilds'],1) |
| self.assertTrue(all(count==1 for count in s._refs.values())) |
| s.transact({'/a':b'y'},'two');s.reset_stats();s.checkpoint() |
| self.assertEqual(s.stats['full_graph_scans'],0);self.assertEqual(s.stats['pool_rebuilds'],0) |
| def test_epoch_exhaustion_no_io(self): |
| with self.create() as s: |
| s.epoch=m.MAX_U64;s.reset_stats() |
| with self.assertRaises(m.StoreError):s.transact({'/a':b'x'},'one') |
| self.assertEqual(s.stats['write_calls'],0) |
|
|
| def test_lazy_heap_order_is_exact_and_nondestructive(self): |
| import heapq,random |
| rng=random.Random(1345) |
| for n in (0,1,2,7,100,1000): |
| heap=rng.sample(range(10000),n);heapq.heapify(heap);before=list(heap) |
| self.assertEqual(list(m.PageStore._heap_order(heap)),sorted(before));self.assertEqual(heap,before) |
| def test_admission_and_plan_query_do_not_write_or_reserve(self): |
| with self.create({'/a':b'old'}) as s: |
| free=list(s._free);owners=dict(s._block_owner);refs=dict(s._refs);s.reset_stats() |
| s.transact({'/a':b'new'},'offer') |
| self.assertEqual(s._free,free);self.assertEqual(s._block_owner,owners);self.assertEqual(s._refs,refs) |
| calls=s.stats['write_calls'];forces=s.stats['fsync_calls'];plans=s.stats['admission_plans'] |
| answer=s.checkpoint_plan(include_writes=True) |
| self.assertGreater(answer['physical_blocks'],0) |
| self.assertEqual(s.stats['write_calls'],calls);self.assertEqual(s.stats['fsync_calls'],forces) |
| self.assertEqual(s.stats['admission_plans'],plans+1) |
| def test_checkpoint_executes_exact_admitted_bytes_without_rebuild(self): |
| with self.create({'/a':b'old'}) as s: |
| s.transact({'/a':bytes(9000),'/b':b'inline'},'offer') |
| plan=s.checkpoint_plan(include_writes=True);writes=[];boundaries=[];original_write=s._pwrite;original_sync=s._sync |
| def write(raw,offset):writes.append((offset,bytes(raw)));return original_write(raw,offset) |
| def sync():boundaries.append(len(writes));return original_sync() |
| with mock.patch.object(s,'_prepare_checkpoint_plan',side_effect=AssertionError('must use admitted plan')): |
| with mock.patch.object(s,'_pwrite',write),mock.patch.object(s,'_sync',sync):s.checkpoint() |
| self.assertEqual(tuple(writes),plan['writes']);self.assertEqual(tuple(boundaries),plan['force_boundaries']) |
| self.assertEqual(sum(len(raw) for _,raw in writes),plan['bytes_written']) |
| def test_rejected_offer_drains_previous_certified_window(self): |
| with self.create(pool=32) as s: |
| s.transact({'/a':b'fits'},'ack');before=s.checkpoint_plan(include_writes=True) |
| with self.assertRaises(m.AdmissionRejected):s.transact({'/b':bytes(45000)},'reject') |
| self.assertEqual(s.get('/a'),b'fits');self.assertIsNone(s.query('reject'));s.checkpoint() |
| self.assertFalse(s.fenced) |
| def test_recovery_recompiles_exact_acked_tail(self): |
| with self.create() as s:s.transact({'/a':bytes(8000)},'ack') |
| with m.PageStore(self.path) as s: |
| self.assertEqual(s.checkpoint_plan()['epoch'],1);s.checkpoint() |
| self.assertEqual(s.get('/a'),bytes(8000));self.assertEqual(s.query('ack')['epoch'],1) |
| def test_readonly_plan_query_has_no_writes(self): |
| with self.create() as s:s.transact({'/a':b'x'},'ack') |
| before=self.path.read_bytes() |
| with m.PageStore(self.path,writable=False) as s: |
| self.assertEqual(s.checkpoint_plan()['epoch'],1);self.assertEqual(s.stats['write_calls'],0) |
| self.assertEqual(self.path.read_bytes(),before) |
| def test_caller_dictionary_changes_do_not_change_admitted_intent(self): |
| with self.create() as s: |
| request={'/a':b'original'};preview=s._reservation_preview |
| def changed(*args):request['/a']=b'changed-after-validation';return preview(*args) |
| with mock.patch.object(s,'_reservation_preview',changed):s.transact(request,'ack') |
| self.assertEqual(s.get('/a'),b'original');s.checkpoint();self.assertEqual(s.get('/a'),b'original') |
| def test_admitted_plan_holds_after_multiple_overwrites(self): |
| with self.create({'/a':b'initial'},pool=256) as s: |
| for i in range(40): |
| s.transact({'/a':bytes([i])*((i%5)*1000+10)},f'token-{i}') |
| self.assertEqual(s.checkpoint_plan()['epoch'],i+1) |
| s.checkpoint();self.assertEqual(s.get('/a'),bytes([39])*4010) |
| def test_fast_admissions_do_not_compile_pending_window(self): |
| with self.create({f'/f{i}':bytes(128) for i in range(200)},pool=1024) as s: |
| s.reset_stats() |
| with mock.patch.object(s,'_prepare_checkpoint_plan',side_effect=AssertionError('fast path recompiled')): |
| for i in range(64):s.transact({f'/f{i}':bytes([i])*128},f'fast-{i}') |
| summary=s.admission_reservation() |
| self.assertEqual(summary['certificate_kind'],'upper_bound') |
| self.assertTrue(summary['tail_certified']);self.assertEqual(s.stats['reservation_fast_accepts'],64) |
| self.assertEqual(s.stats['admission_plans'],0) |
| self.assertLessEqual(len(s._prepare_checkpoint_plan()['dependency_writes']),summary['reserved_upper_blocks']) |
| s.checkpoint() |
| def test_symbolic_bound_dominates_mixed_exact_plans(self): |
| import random |
| rng=random.Random(7047) |
| with self.create({f'/f{i}':rng.randbytes(128) for i in range(300)},pool=2048) as s: |
| for i in range(120): |
| changes={f'/f{rng.randrange(350)}':None if i%9==0 else rng.randbytes((0,128,256,257,3992,8000)[i%6])} |
| s.transact(changes,f'mixed-{i}') |
| if i%7==0: |
| bound=s.admission_reservation()['reserved_upper_blocks'] |
| actual=len(s._prepare_checkpoint_plan()['dependency_writes']) |
| self.assertLessEqual(actual,bound) |
| if i%30==29:s.checkpoint() |
| def test_blob_credit_is_replaced_not_accumulated(self): |
| with self.create(pool=256) as s: |
| s.transact({'/a':bytes(30000)},'big');large=s.admission_reservation()['reserved_upper_blocks'] |
| s.transact({'/a':b'small'},'small');small=s.admission_reservation()['reserved_upper_blocks'] |
| self.assertGreater(large,small+10) |
| self.assertEqual(s._reservation_blob_pages['/a'],0);s.checkpoint() |
| def test_loose_bound_uses_exact_fallback_without_false_refusal(self): |
| initial={};used=set() |
| for i in range(1000): |
| key=f'/p{i:04d}/'+('x'*900);nib=m.hash_key(key)[0] |
| if nib not in used:initial[key]=bytes(256);used.add(nib) |
| if len(initial)==4:break |
| with self.create(initial,pool=16) as s: |
| self.assertEqual(len(s._free),4);key=next(iter(initial));s.reset_stats() |
| s.transact({key:initial[key]},'same') |
| self.assertEqual(s.stats['reservation_exact_fallbacks'],1) |
| self.assertEqual(s.admission_reservation()['certificate_kind'],'exact_plan') |
| self.assertGreater(s.admission_reservation()['reserved_upper_blocks'],len(s._free)) |
| self.assertEqual(s.checkpoint_plan()['physical_blocks'],4);s.checkpoint() |
| def test_reservation_failure_does_not_adopt_proposal(self): |
| import copy |
| with self.create({'/a':b'old'},pool=256) as s: |
| s.transact({'/a':b'accepted'},'one');before=copy.deepcopy(s._reservation_cells) |
| bound=s._reservation_logical;s.reset_stats() |
| with mock.patch.object(m.PageStore,'_budget_update',side_effect=MemoryError('symbolic OOM')): |
| with self.assertRaises(MemoryError):s.transact({'/a':b'offer'},'two') |
| self.assertEqual(s._reservation_cells,before);self.assertEqual(s._reservation_logical,bound) |
| self.assertEqual(s.stats['write_calls'],0);self.assertIsNone(s.query('two'));self.assertFalse(s.fenced) |
| s.checkpoint() |
| def test_generation_exhaustion_rejects_fast_offer_without_io(self): |
| with self.create(pool=256) as s: |
| s.generation=m.MAX_U64;s.reset_stats() |
| with self.assertRaises(m.StoreError):s.transact({'/a':b'no'},'exhausted') |
| self.assertEqual(s.stats['write_calls'],0);self.assertEqual(s.epoch,0) |
| def test_bound_reconstructed_after_reopen(self): |
| with self.create({'/a':b'old'},pool=256) as s: |
| s.transact({'/a':bytes(9000),'/b':b'new'},'accepted') |
| bound=s.admission_reservation()['reserved_upper_blocks'] |
| with m.PageStore(self.path) as s: |
| self.assertEqual(s.admission_reservation()['reserved_upper_blocks'],bound) |
| self.assertLessEqual(s.checkpoint_plan()['physical_blocks'],bound);s.checkpoint() |
| def test_format_maximum_reference_containers_fit(self): |
| self.assertLessEqual(len(m.canonical({'family':'tokens','type':'branch','depth':63,'children':{n:m.BOUND_DESC for n in m.HEX}})),m.PAGE_PAYLOAD) |
| self.assertLessEqual(len(m.canonical({'length':m.MAX_CAPSULE,'digest':'f'*64,'chunks':[m.BOUND_DESC]*17})),m.PAGE_PAYLOAD) |
| def test_weighted_budget_never_serializes_nonempty_symbolic_leaf(self): |
| real=m.canonical |
| def guarded(obj): |
| if isinstance(obj,dict) and obj.get('type')=='leaf' and obj.get('entries'): |
| raise AssertionError('whole symbolic leaf serialized') |
| return real(obj) |
| with self.create(pool=2048) as store: |
| with mock.patch.object(m,'canonical',side_effect=guarded), \ |
| mock.patch.object(store,'_prepare_checkpoint_plan',side_effect=AssertionError('late exact plan')), \ |
| mock.patch.object(store,'_reservation_count',side_effect=AssertionError('whole cell recounted')): |
| for i in range(32): |
| store.transact({f'/new/{i:03d}/{j}':bytes([i])*128 for j in range(8)},f'weighted-{i}') |
| bound=store.admission_reservation()['reserved_upper_blocks'] |
| self.assertGreater(store.stats['reservation_leaf_splits'],0) |
| self.assertEqual(store.stats['reservation_fast_accepts'],32) |
| self.assertLessEqual(len(store._prepare_checkpoint_plan()['dependency_writes']),bound) |
| store.checkpoint() |
| def test_equal_size_replacement_reuses_file_budget_identity(self): |
| with self.create(pool=2048) as store: |
| store.transact({f'/item/{i:03d}':bytes(128) for i in range(40)},'seed') |
| anchor=store._reservation_route('files','/item/000')[0] |
| previous=store._reservation_cells[anchor]['tree'] |
| store.transact({'/item/000':b'x'*128},'replace') |
| self.assertIs(store._reservation_cells[anchor]['tree'],previous) |
| store.checkpoint();self.assertEqual(store.get('/item/000'),b'x'*128) |
| def test_partial_weighted_proposal_failure_preserves_accepted_tree(self): |
| with self.create(pool=2048) as store: |
| store.transact({'/old':b'accepted'},'accepted') |
| before=dict(store._reservation_cells);budget=store._reservation_logical |
| calls=0;update=store._budget_update |
| def fail(family,node,key,weight,depth,hashed=None): |
| nonlocal calls |
| calls+=1 |
| if calls==2:raise MemoryError('second weighted edit') |
| return update(family,node,key,weight,depth,hashed) |
| store.reset_stats() |
| with mock.patch.object(store,'_budget_update',side_effect=fail): |
| with self.assertRaises(MemoryError):store.transact({'/new/1':b'a','/new/2':b'b'},'refused') |
| self.assertEqual(store._reservation_cells,before);self.assertEqual(store._reservation_logical,budget) |
| self.assertEqual(store.stats['write_calls'],0);self.assertEqual(store.epoch,1) |
| self.assertIsNone(store.query('refused'));self.assertFalse(store.fenced) |
| store.checkpoint() |
| def test_weighted_leaf_byte_identity_for_escaped_published_values(self): |
| paths=('/plain','/quote\"/line\n','/雪/😀','/'+chr(1)*500) |
| with self.create(pool=1024) as store: |
| for depth in (0,9,10,63,64): |
| entries={path:{'inline':m.b64(bytes([i])*128)} for i,path in enumerate(paths)} |
| weights={key:store._budget_published_weight('files',key,value) for key,value in entries.items()} |
| predicted=store._budget_leaf_bytes('files',depth,weights,sum(weights.values())) |
| self.assertEqual(predicted,len(m.canonical({'family':'files','type':'leaf','depth':depth,'entries':entries}))) |
| for epoch in (1,9,10,m.MAX_U64): |
| token='receipt_09';value=[epoch,'a'*64] |
| self.assertEqual(store._budget_published_weight('tokens',token,value),len(m.canonical(token))+1+len(m.canonical(value))) |
| desc=[0,m.MAX_POOL_BLOCKS-1,m.MAX_U64,m.K_BLOB,m.PAGE_PAYLOAD,'f'*64] |
| self.assertEqual(store._budget_published_weight('files',paths[2],{'blob':desc}),len(m.canonical(paths[2]))+1+len(m.canonical({'blob':desc}))) |
| def test_published_entry_weights_are_computed_once_per_cell(self): |
| with self.create({'/same':bytes(128)},pool=512) as store: |
| store.transact({'/same':b'a'*128},'first') |
| with mock.patch.object(store,'_budget_published_weight',side_effect=AssertionError('published cell reweighted')): |
| for i in range(12):store.transact({'/same':bytes([i])*128},f'overwrite-{i}') |
| store.checkpoint() |
| if __name__=='__main__':unittest.main() |
|
|
