Files
CyberGril/tests/test_r3.py
T
zonggongandmultica-agent e291058754 HEL-882 rework: execution-table caps become real hard gates at the wire, SDK hidden retries and mid-add failures recover without loss, the 8360 release package runs offline, and the HEL-874 embedding evidence is corrected - every real provider exit (create/dialogue/life/gist/judgment/growth/proactive phrasing + mem0's internal extraction LLM) now persistently pre-allocates request count (per-category daily + one-shot totals in request_usage/budget_total, BEGIN IMMEDIATE) and a conservative token estimate before sending, refuses at the tightest cap (BudgetStop, no more downgrade-and-keep-calling) and survives restarts; known usage settles to actual, unknown/disconnect/failure keeps the full reservation; ledger guards gain per-day tops (embed_daily/llm_daily) and verify_ledger_authority rejects a fresh file bypassing the frozen 498/500 prefix; the mem0 SDK client's hidden OpenAI retries are disabled (max_retries=0) so every actual send is gated and answered failures (even 5xx) settle as used with only httpx.ConnectError-grade unsent requests released; embed refusals the SDK swallows into empty adds are re-raised as budget errors so the batch re-queues without burning an attempt and resumes when the cap returns, add_group resumes at vector-store level (src_group anchors: only missing rows resent, crash/restart/concurrency never duplicate), sem coverage is per-backend (stub batches no longer block a real rebuild, real done batches never resend) with backend-scoped batch keys; the release package is offline-executable: fresh-dir git clone, cybergril service account, PYTHONPATH in the unit so the lock-only venv imports the product, shipped caps explicitly 0 (=refuse by design until approved), deploy/mem0-stack.lock + accurate 3.11 wheel gap with a no-download path (hel857-venv is 3.10; never present stub/FTS as the real memory experience), and tools/check_release_offline_hel882.py verifies checkout/import/health/fail-closed/approved-run/data-preservation on loopback with echo stand-ins; evidence corrected per manager review: docs/rework/hel874/erratum-hel882.json + README appendix record that e978e87's verification did real local embeddings from cache (provable lower bound 12, exact total unrecoverable, temp sandbox gone) while zero-real-LLM/zero-download/zero-outbound stand, old JSONs and authoritative ledgers untouched, and tools/verify_mem0_real_hel874.py now installs the deterministic 512-dim stand-in before TextEmbedding construction plus non-loopback socket rejection (zero model loads) with final_embed_rows persisted before temp cleanup; verification: 272 python tests pass on 3.11.16 venv + requirements.lock offline (16 new: manager api repro blocked with 0 provider calls, sdk repro 1-HTTP/max_retries=0/llm_ops=1, mid-add swallow requeued-then-resumed, resume-no-duplicate, stub-to-mem0 rebuild, daily embed cap, unified mem0-LLM gate, authority refusal, restart-persistent counters, tightest-constraint settle/release), ruff clean (src/tests/tools), web tsc + 42 vitest + build via npm ci --offline, pinned-install deterministic re-run 12/12, manager review scripts re-run evidence attached in delivery, dual-target requirement checks 4/4 with handoff-HEL-882.json; zero real calls, zero real embeddings, zero non-loopback outbound, authoritative ledgers and freezes untouched, not deployed, PR not merged, no visual changes
Co-authored-by: multica-agent <github@multica.ai>
2026-10-26 23:20:18 +08:00

483 lines
23 KiB
Python

"""R3 acceptance: isolated SQLite, controlled providers, injected clocks, no upstream."""
import asyncio
import json
import logging
import sqlite3
import subprocess
from uuid import uuid4
import httpx
import pytest
from conftest import engineering_budget
from fastapi.testclient import TestClient
from test_api import CREATE, ControlledLLM, events, live_server, make_app, turn
from test_r2 import ack, add_life, app_for, final_and_receipt
from cybergril.config import load_settings
from cybergril.contracts import LLMDelta
from cybergril.life.persona import fingerprint
from cybergril.life.runtime import LifeRuntime
from cybergril.memory.episodic import Memories
from cybergril.memory.store import Store
from cybergril.think.router import build_router
from cybergril.think.scenes import Tier
BASE = 'c285a0fd07e9d20e4fd4984942f3ae2fb8cbbd0c'
SECRET = '私密紫铜风铃独特关键词'
PROTECTED = ('bazi_core', 'companion', 'persona_interp', 'persona_seed', 'persona_job',
'growth_event', 'growth_job', 'life_event', 'telling_log', 'sharing_attempt')
def snapshot(store):
return {table: [tuple(r) for r in store.query(f'SELECT * FROM {table} ORDER BY rowid')]
for table in PROTECTED}
def seed(mem, text='杭州的雨声让我安静下来', reply='普通答复', *, gist=True):
s, tid = mem.store, str(uuid4())
with s.conn:
for role, raw in [('user', text), ('companion', reply)]:
s.execute("INSERT INTO chat_message(ts,role,text,turn_id,status) VALUES(1,?,?,?,'sent')",
(role, raw, tid))
mem.record_turn(tid)
if gist:
for row in s.query('SELECT * FROM mem_episodic WHERE turn_id=?', (tid,)):
s.set_gist(row['id'], row['raw'], {'v': .1, 'a': .2, 'd': .3})
return tid, s.query_one("SELECT id FROM mem_episodic WHERE turn_id=? AND role='user'", (tid,))[0]
class GistLLM(ControlledLLM):
def __init__(self):
super().__init__()
self.jobs = []
self.bad = False
self.entered = asyncio.Event()
self.release = asyncio.Event()
self.block = False
async def stream(self, messages, **kwargs):
self.jobs.append((messages, kwargs))
self.entered.set()
if self.block:
await self.release.wait()
if self.bad:
raise OSError('controlled compression failure')
yield LLMDelta(text=json.dumps({'gist': '杭州雨声里的安静时刻',
'affect': {'v': .2, 'a': -.1, 'd': .3}}))
yield LLMDelta(done=True)
@pytest.fixture
def memory(tmp_path):
with Store(tmp_path / 'memory.db') as s:
p = GistLLM()
router = build_router(providers={t: p for t in (Tier.HIGH, Tier.STANDARD, Tier.LOW)},
budget=engineering_budget())
clock = [1000.0]
yield Memories(s, router, load_settings().models, clock=lambda: clock[0]), p, clock
def test_chinese_probe_and_legacy_tokenizer(memory):
mem, _, _ = memory
_, mid = seed(mem)
s = mem.store
assert not s.search_fts('雨声')
assert [r['id'] for r in mem.search('杭州的雨')[0]] == [mid]
assert mem.search('杭州的雨')[1] == 'phrase'
assert mem.search('雨声')[1] == 'like'
assert mem.search('雨')[1] == 'like'
assert not s.query("SELECT rowid FROM mem_fts_zh WHERE mem_fts_zh MATCH '雨声'")
short_like = s.query("SELECT rowid FROM mem_fts_zh WHERE raw LIKE '%雨声%'")
print(f'SQLite {sqlite3.sqlite_version}: trigram short LIKE rows={len(short_like)}; short MATCH=0')
traced = []
s.conn.set_trace_callback(traced.append)
assert mem.search('雨声')[1] == 'like'
s.conn.set_trace_callback(None)
assert any('FROM mem_episodic WHERE' in q and 'LIKE' in q for q in traced)
assert not any('FROM mem_fts_zh' in q for q in traced)
assert mem.search('想起杭州的雨声那一天')[1] == 'trigram'
assert mem.search('只是杭州的')[0] == [] # a lone trigram is noise
assert sqlite3.sqlite_version_info >= (3, 34)
@pytest.mark.parametrize('query', ['难过"', 'a OR b', 'NEAR(a b)', 'rain*', '"unclosed',
'a-b', '雨声" OR 1=1 --', '\x00', '', '***', '"杭州的雨"'])
def test_untrusted_match_syntax_is_only_data(memory, query):
mem, _, _ = memory
seed(mem)
seed(mem, text=SECRET)
assert all(SECRET not in r['raw'] for r in mem.search(query)[0])
def test_search_topk_floor_exclusion_noise_budget_and_logs(memory, caplog):
mem, _, _ = memory
ids, tids = [], []
for _ in range(7):
tid, mid = seed(mem)
ids.append(mid)
tids.append(tid)
s = mem.store
with s.conn:
s.execute('UPDATE mem_episodic SET accessibility=.04 WHERE id=?', (ids[-1],))
hits, _ = mem.search('杭州的雨', tids[-3:-1])
assert len(hits) == 4
assert {r['id'] for r in hits}.isdisjoint(ids[-3:])
with caplog.at_level(logging.INFO, logger='cybergril.memory.episodic'):
block = mem.context('杭州的雨', 'new-turn', tids[-3:-1], 600)
assert len(block) <= 600
logged = json.loads(caplog.records[-1].message)
assert logged['turn_id'] == 'new-turn' and logged['mode'] == 'phrase'
assert logged['hits'] and all({'id', 'turn_id', 'rank'} == set(h) for h in logged['hits'])
assert all(s.query_one('SELECT recall_count FROM mem_episodic WHERE id=?', (h['id'],))[0] == 1
for h in logged['hits'])
assert mem.context('杭州的雨', 'x', [], 1) == ''
assert mem.context('完全无匹配的事情', 'x', [], 600) == ''
with s.conn:
s.execute("UPDATE life_control SET value='off' WHERE key='memory_search'")
assert mem.context('杭州的雨', 'x', [], 600) == ''
@pytest.mark.asyncio
async def test_jobs_retries_recovery_dual_indexes_and_clock(memory):
mem, p, clock = memory
_, mid = seed(mem, gist=False)
s = mem.store
with s.conn:
s.execute('DELETE FROM mem_job WHERE memory_id<>?', (mid,))
before = snapshot(s)
p.bad = True
for _ in range(4):
await mem.tick()
assert len(p.jobs) == 3
job = s.query_one('SELECT * FROM mem_job WHERE memory_id=?', (mid,))
assert job['state'] == 'failed' and job['attempts'] == 3
assert s.query_one('SELECT gist,affect FROM mem_episodic WHERE id=?', (mid,))[:] == (None, None)
# Restart recovery must not steal a live lease, and must use the injected clock.
with s.conn:
s.execute("UPDATE mem_job SET state='pending',attempts=1,owner='dead',lease_until=? WHERE memory_id=?",
(int(clock[0] * 1000) + 1000, mid))
mem.recover()
assert s.query_one('SELECT state FROM mem_job WHERE memory_id=?', (mid,))[0] == 'pending'
clock[0] += 2
mem.recover()
assert s.query_one('SELECT reason FROM mem_job WHERE memory_id=?', (mid,))[0] == 'lease_expired'
p.bad = False
await mem.tick()
assert s.query_one('SELECT state FROM mem_job WHERE memory_id=?', (mid,))[0] == 'done'
assert mem.search('杭州雨声')[0]
assert s.search_fts('杭州雨声里的安静时刻')
assert snapshot(s) == before
assert p.jobs[-1][1]['temperature'] == .4
assert p.jobs[-1][1]['max_tokens'] == 400
assert set(json.loads(p.jobs[-1][0][1].content)) == {'role', 'raw'}
watermark = float(s.query_one("SELECT value FROM life_control WHERE key='last_mem_decay'")[0])
clock[0] = watermark + 3599
mem.decay()
assert s.query_one('SELECT accessibility FROM mem_episodic WHERE id=?', (mid,))[0] == 1
clock[0] = watermark + 3600
mem.decay()
value = s.query_one('SELECT accessibility FROM mem_episodic WHERE id=?', (mid,))[0]
assert .03 < value < 1
mem.decay()
assert s.query_one('SELECT accessibility FROM mem_episodic WHERE id=?', (mid,))[0] == value
@pytest.mark.asyncio
async def test_cancelled_worker_restart_lease_and_no_duplicate_claim(memory):
mem, p, clock = memory
_, mid = seed(mem, gist=False)
# Only one job here to expose concurrent claim duplication clearly.
with mem.store.conn:
mem.store.execute('DELETE FROM mem_job WHERE memory_id<>?', (mid,))
p.block = True
task = asyncio.create_task(mem.tick())
await p.entered.wait()
await mem.tick()
assert len(p.jobs) == 1
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
assert mem.store.query_one('SELECT gist FROM mem_episodic WHERE id=?', (mid,))[0] is None
clock[0] += 41
p.block = False
await mem.tick()
assert len(p.jobs) == 2
assert mem.store.query_one('SELECT state FROM mem_job')[0] == 'done'
def test_success_replay_restart_and_transaction_rollback(tmp_path, monkeypatch):
path = tmp_path / 'chat.db'
app, _ = make_app(path)
with TestClient(app) as c:
c.post('/api/companion', json=CREATE)
tid = str(uuid4())
assert events(turn(c, turn_id=tid))[-1]['t'] == 'chat.final'
s = app.state.store
saved = [tuple(r) for r in s.query('SELECT * FROM mem_episodic')]
assert len(saved) == 2 and len(s.query('SELECT * FROM mem_job')) == 2
assert events(turn(c, turn_id=tid))[-1]['t'] == 'chat.final'
assert [tuple(r) for r in s.query('SELECT * FROM mem_episodic')] == saved
original = s.execute
def fail_job(sql, params=()):
if 'INSERT OR IGNORE INTO mem_job' in sql:
raise OSError('disk-full')
return original(sql, params)
monkeypatch.setattr(s, 'execute', fail_job)
failed = str(uuid4())
assert events(turn(c, turn_id=failed))[-1]['t'] == 'chat.error'
assert not s.query('SELECT id FROM mem_episodic WHERE turn_id=?', (failed,))
assert not s.query("SELECT id FROM chat_message WHERE turn_id=? AND status='sent'", (failed,))
app2, p2 = make_app(path)
with TestClient(app2) as c:
assert events(turn(c, turn_id=tid))[-1]['t'] == 'chat.final'
assert all('只返回JSON,不要Markdown' in call[0].content for call in p2.calls)
assert len(app2.state.store.query('SELECT * FROM mem_episodic')) == 2
@pytest.mark.parametrize('mode', ['error', 'truncated'])
def test_failed_turn_has_no_raw_or_job(tmp_path, mode):
app, p = make_app(tmp_path / 'chat.db')
with TestClient(app) as c:
c.post('/api/companion', json=CREATE)
p.mode = mode
assert events(turn(c))[-1]['t'] == 'chat.error'
assert not app.state.store.query('SELECT * FROM mem_episodic')
assert not app.state.store.query('SELECT * FROM mem_job')
@pytest.mark.asyncio
@pytest.mark.parametrize('cancel', [False, True])
async def test_disconnect_and_explicit_cancel_never_create_memory(tmp_path, cancel):
app, p = make_app(tmp_path / 'chat.db')
with live_server(app) as url:
async with httpx.AsyncClient(base_url=url) as c:
await c.post('/api/companion', json=CREATE)
epoch = (await c.get('/api/health')).json()['epoch']
tid = str(uuid4())
p.mode = 'slow'
async with c.stream('POST', '/api/chat', json={'text': '取消我', 'turn_id': tid, 'epoch': epoch}) as r:
async for line in r.aiter_lines():
if line.startswith('data:'):
break
if cancel:
p.mode = 'normal'
response = await c.post('/api/chat', json={'text': '打断这一轮', 'turn_id': str(uuid4()), 'epoch': epoch})
assert events(response)[-1]['t'] == 'chat.final'
p.mode = 'normal'
assert events(await c.post('/api/chat', json={'text': '新的轮次', 'turn_id': str(uuid4()), 'epoch': epoch}))[-1]['t'] == 'chat.final'
assert not app.state.store.query('SELECT * FROM mem_episodic WHERE turn_id=?', (tid,))
assert len(app.state.store.query('SELECT * FROM mem_job')) == (4 if cancel else 2)
@pytest.mark.parametrize('case', ['unacknowledged', 'unjudged', 'private_candidate', 'unknown'])
def test_private_companion_entire_memory_hidden_at_every_stage(tmp_path, case):
app, p = app_for(tmp_path)
with TestClient(app) as c:
c.post('/api/companion', json=CREATE)
eid = add_life(app.state.store, SECRET)
p.reply = SECRET
_, receipt = final_and_receipt(c)
s, mem = app.state.store, app.state.memories
if case != 'unacknowledged':
assert ack(c, receipt).status_code == 200
if case in ('unacknowledged', 'private_candidate'):
c.portal.call(app.state.sharing.judge, receipt['message_id'])
row = s.query_one("SELECT * FROM mem_episodic WHERE role='companion'")
if case == 'unknown':
with s.conn:
s.execute("UPDATE mem_episodic SET source='unknown' WHERE id=?", (row['id'],))
before, birth = snapshot(s), fingerprint(s)
# Compress both raw rows, including the private one: visibility cannot rely on NULL gist.
for _ in range(2):
c.portal.call(mem.tick)
private = s.query_one('SELECT * FROM mem_episodic WHERE id=?', (row['id'],))
assert private['raw'] == SECRET and private['gist'] == SECRET
assert mem.source(private) is None and mem.dto(private) is None
assert not mem.search(SECRET)[0]
assert mem.context(SECRET, 'next', [], 600) == ''
response = c.get('/api/memories').json()
assert SECRET not in json.dumps(response, ensure_ascii=False)
assert str(private['id']) not in [r['id'] for r in response['memories']]
for mid in (str(private['id']), '999999', 'fake', '-1', '0', '99999999999999999999999999'):
r = c.get('/api/memories/' + mid)
assert r.status_code == 404 and r.json() == {'detail': '这一条现在打不开。'}
assert s.query_one('SELECT told FROM life_event WHERE id=?', (eid,))[0] == 0
assert snapshot(s) == before and fingerprint(s) == birth
def test_memories_dto_pagination_visibility_epoch_and_source_links(tmp_path):
app, _ = app_for(tmp_path)
with TestClient(app) as c:
c.post('/api/companion', json=CREATE)
mem, s = app.state.memories, app.state.store
public_ids = [seed(mem, text='回忆' + str(i))[1] for i in range(4)]
_, receipt = final_and_receipt(c)
assert ack(c, receipt).status_code == 200
c.portal.call(app.state.sharing.judge, receipt['message_id'])
visible = add_life(s, '已公开生活', told=1)
hidden = add_life(s)
companion = s.query_one("SELECT * FROM mem_episodic WHERE message_id=?", (receipt['message_id'],))
with s.conn:
s.set_gist(companion['id'], '已压缩的真实聊天要点', {'v': 0, 'a': 0, 'd': 0})
s.execute('INSERT INTO telling_log VALUES(?,?,1)', (visible, receipt['message_id']))
s.execute('INSERT INTO telling_log VALUES(?,?,1)', (hidden, receipt['message_id']))
pages, cursor = [], None
while True:
params = {'limit': 2} | ({'before': cursor} if cursor else {})
data = c.get('/api/memories', params=params).json()
assert data['epoch'] == app.state.epoch
pages.extend(data['memories'])
cursor = data['next_before']
if cursor is None:
break
assert [int(r['id']) for r in pages] == [companion['id'], *reversed(public_ids)]
dto = pages[0]
assert dto == {'id': str(companion['id']), 'title': '已压缩的真实聊天要点', 'text': '已压缩的真实聊天要点',
'group': '我们一起的', 'source': mem.dto(s.query_one('SELECT * FROM mem_episodic WHERE id=?', (companion['id'],)))['source'],
'lifeIds': [visible], 'messageIds': [receipt['message_id']], 'ts': companion['ts']}
assert c.get('/api/memories/' + dto['id']).json() == {'memory': dto, 'epoch': data['epoch']}
for q in ('limit=0', 'limit=101', 'before=0', 'before=99999999999999999999999'):
assert c.get('/api/memories?' + q).status_code == 422
def test_real_chat_retrieval_excludes_twenty_turns_and_preserves_birth(tmp_path, caplog):
app, p = make_app(tmp_path / 'chat.db')
with TestClient(app) as c:
c.post('/api/companion', json=CREATE)
birth = fingerprint(app.state.store)
_, old = seed(app.state.memories, '杭州的雨声让我安静下来')
for i in range(20):
seed(app.state.memories, f'杭州的雨近轮第{i}次话题')
assert app.state.memories.context('杭州的雨', 'probe', [], 600)
with caplog.at_level(logging.INFO, logger='cybergril.memory.episodic'):
assert events(turn(c, '杭州的雨'))[-1]['t'] == 'chat.final'
context = p.calls[-1]
block = next(m.content for m in context[1:] if m.role == 'system')
assert '杭州的雨声让我安静下来' in block and len(block) <= 600
assert '近轮' not in block
assert sum(len(m.content) for m in context) <= 4000
assert '原始' in context[0].content or '出生' in context[0].content
logged = json.loads(caplog.records[-1].message)
assert old in [h['id'] for h in logged['hits']]
assert fingerprint(app.state.store) == birth
assert c.get('/api/health').json()['capabilities']['memory'] is True
with app.state.store.conn:
app.state.store.execute("UPDATE life_control SET value='off' WHERE key='memory_search'")
assert c.get('/api/health').json()['capabilities']['memory'] is False
assert events(turn(c, '杭州的雨'))[-1]['t'] == 'chat.final'
assert all(m.role != 'system' for m in p.calls[-1][1:])
assert '长期检索已关闭' in p.calls[-1][0].content
def test_startup_factory_clock_precedes_recovery(tmp_path, monkeypatch):
path = tmp_path / 'chat.db'
with Store(path) as s:
router = build_router(providers={Tier.LOW: ControlledLLM()}, budget=engineering_budget())
mem = Memories(s, router, load_settings().models)
seed(mem, gist=False)
with s.conn:
s.execute("UPDATE mem_job SET state='pending',lease_until=200000,owner='old'")
monkeypatch.setattr('cybergril.api.app.LifeRuntime', lambda *args: LifeRuntime(*args, clock=lambda: 100.0))
app, _ = make_app(path)
with TestClient(app):
assert app.state.memories.clock() == 100.0
assert all(r['state'] == 'pending' for r in app.state.store.query('SELECT state FROM mem_job'))
app.state.life.clock = lambda: 201.0
app.state.memories.recover()
assert all(r['state'] == 'failed' for r in app.state.store.query('SELECT state FROM mem_job'))
def test_populated_migration_idempotence_and_old_code_rollback(tmp_path):
# Execute the exact product-base Store, not a handwritten imitation of old writes.
old = tmp_path / 'legacy'
old.mkdir()
for name in ('store.py', 'schema.sql', 'r2.sql'):
(old / name).write_bytes(subprocess.check_output(['git', 'show', f'{BASE}:src/cybergril/memory/{name}']))
import importlib.util
spec = importlib.util.spec_from_file_location('legacy_store', old / 'store.py')
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
path = tmp_path / 'migrate.db'
with module.Store(path) as s:
first = s.add_episodic(role='user', raw='迁移之前杭州的雨声', salience=.5)
original = tuple(s.query_one('SELECT * FROM mem_episodic WHERE id=?', (first,)))
for _ in range(2):
with Store(path) as s:
assert tuple(s.query_one('SELECT * FROM mem_episodic WHERE id=?', (first,)))[:len(original)] == original
assert len(s.query("SELECT rowid FROM mem_fts_zh WHERE mem_fts_zh MATCH '\"杭州的雨\"'")) == 1
s.execute("INSERT INTO mem_fts_zh(mem_fts_zh,rank) VALUES('integrity-check',1)")
with module.Store(path) as s:
second = s.add_episodic(role='user', raw='回退期间西湖的风声', salience=.6)
assert len(s.search_fts('回退期间西湖的风声')) == 1
with Store(path) as s:
assert s.query("SELECT rowid FROM mem_fts_zh WHERE mem_fts_zh MATCH '\"西湖的风\"'")[0][0] == second
with s.conn:
s.set_gist(first, '压缩以后独特新词汇', {'v': 0, 'a': 0, 'd': 0})
assert s.search_fts('压缩以后独特新词汇')
assert s.query("SELECT rowid FROM mem_fts_zh WHERE mem_fts_zh MATCH '\"独特新词\"'")
for table in ('mem_fts', 'mem_fts_zh'):
s.execute(f"INSERT INTO {table}({table},rank) VALUES('integrity-check',1)")
def test_three_endpoint_bytes_equal_product_baseline(tmp_path):
import os
import sys
from pathlib import Path
root = Path(__file__).resolve().parents[1]
old = tmp_path / 'baseline'
old.mkdir()
# Exact tracked source extraction only; no databases or runtime configuration.
files = subprocess.check_output(['git', 'ls-tree', '-r', '--name-only', BASE, 'src/']).decode().splitlines()
for name in files:
target = old / name
target.parent.mkdir(parents=True, exist_ok=True)
target.write_bytes(subprocess.check_output(['git', 'show', f'{BASE}:{name}']))
results = []
for index, source in enumerate((old / 'src', root / 'src')):
data = tmp_path / f'data-{index}'
data.mkdir()
env = dict(os.environ, PYTHONPATH=os.pathsep.join((str(source), str(root / 'tests'))))
results.append(subprocess.check_output([sys.executable, str(root / 'tests/r3_baseline_probe.py'), str(data)],
cwd=root, env=env, text=True))
assert json.loads(results[0]) == json.loads(results[1])
import hashlib
for endpoint, payload in json.loads(results[0])['responses'].items():
print(f'c285a0f == current {endpoint}: sha256={hashlib.sha256(bytes.fromhex(payload)).hexdigest()}')
def test_direct_record_idempotence_and_unique_role(memory):
mem, _, _ = memory
tid, _ = seed(mem, gist=False)
before = [tuple(r) for r in mem.store.query('SELECT * FROM mem_episodic')]
with mem.store.conn:
mem.record_turn(tid)
assert [tuple(r) for r in mem.store.query('SELECT * FROM mem_episodic')] == before
assert len(mem.store.query('SELECT * FROM mem_job')) == 2
assert all(r['gist'] is None and r['affect'] is None for r in mem.store.query('SELECT * FROM mem_episodic'))
with pytest.raises(sqlite3.IntegrityError), mem.store.conn:
mem.store.add_episodic(role='user', raw='duplicate', salience=.5, turn_id=tid)
@pytest.mark.asyncio
async def test_memory_budget_is_durable_and_hard_stop_makes_no_call(tmp_path):
from cybergril.life.model import PersistentBudget
app, p = app_for(tmp_path)
with TestClient(app) as c:
c.post('/api/companion', json=CREATE)
seed(app.state.memories, gist=False)
guard = app.state.life.router.guard
assert isinstance(guard, PersistentBudget)
before = guard.used
await app.state.memories.tick()
assert guard.used > before
assert app.state.store.query_one("SELECT used FROM token_usage WHERE scene='memory_gist'")[0] > 0
guard.record(guard.limit, 'test-hard-stop')
calls = len(p.memory_calls)
await app.state.memories.tick()
assert len(p.memory_calls) == calls
app2, p2 = app_for(tmp_path)
with TestClient(app2):
assert app2.state.life.router.guard.is_tight()
await app2.state.memories.tick()
assert not p2.memory_calls