Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust
6.8 KB
Raw Blame
import copy
import json
from pathlib import Path
import tempfile
import unittest

from check_saved_catalog import COUNT, PAGE, TARGET, normalize, seed, validate_query


class SavedCatalogGuards(unittest.TestCase):
    def setUp(self):
        self.directory = tempfile.TemporaryDirectory()
        self.addCleanup(self.directory.cleanup)
        self.root = Path(self.directory.name)
        self.expected = seed(self.root)

    def call(self, rows=None, remaining=0, cursor=None):
        rows = copy.deepcopy(self.expected if rows is None else rows)
        for row in rows:
            row['path'] = str(self.root / 'agent/sessions' / row['path'])
        data = {'sessions': rows, 'remaining': remaining}
        if cursor is not None:
            data['nextCursor'] = cursor
        frames = [{'type': 'session_list_item', 'id': '1',
            'command': 'list_saved_sessions', 'session': row} for row in rows]
        frames.append({'type': 'session_list_progress', 'id': '1',
            'command': 'list_saved_sessions', 'loaded': len(rows), 'total': len(rows)})
        frames.append({'type': 'response', 'id': '1', 'success': True,
            'command': 'list_saved_sessions', 'data': data})
        request = {'type': 'command', 'id': '1',
            'command': {'type': 'list_saved_sessions', 'cwd': '/tmp/catalog-paging-fixture',
                        'scope': 'all'}}
        return {'paging': {}, 'frames': frames, 'final_data': data,
            'raw_received_hex': [(json.dumps(frame) + '\n').encode().hex() for frame in frames],
            'raw_sent_hex': [(json.dumps(request) + '\n').encode().hex()]}

    def refresh_raw(self, call):
        call['raw_received_hex'] = [(json.dumps(frame) + '\n').encode().hex()
                                    for frame in call['frames']]

    def check(self, call, rows=None, **kwargs):
        return validate_query(call, self.root, self.expected if rows is None else rows,
                              ordered=True, remaining=0, **kwargs)

    def test_fixture_is_valid_ordered_and_old_target_is_beyond_first_page(self):
        files = sorted((self.root / 'agent/sessions').glob('*.jsonl'))
        self.assertGreater(len(files), PAGE)
        self.assertEqual(len(files), COUNT)
        mtimes = [path.stat().st_mtime_ns for path in files]
        self.assertEqual(len(set(mtimes)), COUNT)
        self.assertEqual(mtimes, sorted(mtimes))
        for path in files:
            entries = [json.loads(line) for line in path.read_text().splitlines()]
            self.assertEqual(entries[0]['type'], 'session')
            self.assertEqual(entries[0]['id'], path.stem)
            self.assertEqual(entries[-1]['message']['role'], 'assistant')
        self.assertNotIn(TARGET, json.dumps(self.expected[:PAGE]))
        self.assertEqual(self.expected[-1]['name'], TARGET)
        self.assertEqual(self.check(self.call()), self.expected)

    def test_rejects_missing_duplicate_or_wrong_rows(self):
        for mutate in (
            lambda rows: rows.pop(),
            lambda rows: rows.append(copy.deepcopy(rows[0])),
            lambda rows: rows[0].update(name='wrong'),
            lambda rows: rows[-1].update(firstMessage='wrong'),
        ):
            call = self.call()
            mutate(call['final_data']['sessions'])
            self.refresh_raw(call)
            with self.assertRaises(AssertionError):
                self.check(call)
        escaped = self.call()
        escaped['final_data']['sessions'][0]['path'] = '/ambient/session.jsonl'
        with self.assertRaises(AssertionError):
            self.check(escaped)

    def test_pages_cover_full_catalog_once_and_wrong_boundary_is_rejected(self):
        first = self.call(self.expected[:PAGE], COUNT - PAGE, 'boundary')
        validate_query(first, self.root, self.expected[:PAGE], ordered=True,
                       remaining=COUNT - PAGE, cursor=True)
        rest = self.call(self.expected[PAGE:])
        self.check(rest, self.expected[PAGE:])
        joined = normalize(first['final_data']['sessions'] + rest['final_data']['sessions'], self.root)
        self.assertEqual(joined, self.expected)
        for key, value in (('remaining', 0), ('nextCursor', '')):
            broken = copy.deepcopy(first)
            broken['final_data'][key] = value
            self.refresh_raw(broken)
            with self.assertRaises(AssertionError):
                validate_query(broken, self.root, self.expected[:PAGE], ordered=True,
                               remaining=COUNT - PAGE, cursor=True)
        with self.assertRaises(AssertionError):
            self.check(self.call(self.expected[PAGE - 1:]), self.expected[PAGE:])
        with self.assertRaises(AssertionError):
            self.check(self.call(self.expected[PAGE:], cursor='not-finished'), self.expected[PAGE:])

    def test_deleted_cursor_boundary_still_requires_the_complete_older_tail(self):
        boundary = self.root / 'agent/sessions' / self.expected[PAGE - 1]['path']
        boundary.unlink()
        self.assertFalse(boundary.exists())
        tail = self.expected[PAGE:]
        self.assertEqual(self.check(self.call(tail), tail), tail)
        self.assertEqual(tail[-1]['name'], TARGET)
        with self.assertRaises(AssertionError):
            self.check(self.call(tail[1:]), tail)

    def test_raw_terminal_and_stream_disagreement_fail_closed(self):
        for mode in ('missing_raw', 'bad_raw', 'wrong_request', 'wrong_stream',
                     'duplicate_stream', 'wrong_order', 'no_stream', 'after_final'):
            call = self.call()
            if mode == 'missing_raw':
                call['raw_received_hex'] = []
            elif mode == 'bad_raw':
                call['raw_received_hex'][0] = b'{}\n'.hex()
            elif mode == 'wrong_request':
                call['raw_sent_hex'] = [b'{"id":"elsewhere","command":{}}\n'.hex()]
            elif mode == 'wrong_stream':
                call['frames'][0] = copy.deepcopy(call['frames'][0])
                call['frames'][0]['session']['firstMessage'] = 'wrong'
            elif mode == 'duplicate_stream':
                call['frames'].insert(0, copy.deepcopy(call['frames'][0]))
            elif mode == 'wrong_order':
                call['frames'][0], call['frames'][1] = call['frames'][1], call['frames'][0]
            elif mode == 'no_stream':
                call['frames'] = call['frames'][-2:]
            else:
                call['frames'].append(copy.deepcopy(call['frames'][0]))
            if mode not in ('missing_raw', 'bad_raw', 'wrong_request'):
                self.refresh_raw(call)
            with self.subTest(mode=mode), self.assertRaises(AssertionError):
                self.check(call)
        # Dropped streamed items are legal under real Rust backpressure.
        call = self.call()
        del call['frames'][1:PAGE]
        self.refresh_raw(call)
        self.check(call)


if __name__ == '__main__':
    unittest.main()