Skip to content

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

Rust

compare prerelease versions correctly in reconnect advice (#3566)

Sebastian Müller18c5519dc20c
diff --git a/crates/pa-tui/src/daemon_reconnect.rs b/crates/pa-tui/src/daemon_reconnect.rs
index 83ae5d2257..6015aeb56f 100644
--- a/crates/pa-tui/src/daemon_reconnect.rs
+++ b/crates/pa-tui/src/daemon_reconnect.rs
@@ -3,6 +3,7 @@
//! is NEWER than this window's binary, the recovered row says so.
use crate::chat::StatusKind;
+use std::cmp::Ordering;
/// The reconnect driver that owns the run: which daemon closing armed it
/// decides the reattach banner and the expiry row.
@@ -55,44 +56,95 @@ pub(crate) fn reconnect_banner(
/// The numeric version prefixes order segment by segment; a numeric-equal
/// release outranks the client's own prerelease (semver: "1.2.3" >
/// "1.2.3-beta.1"), so a prerelease window still gets the restart advice.
+/// Two prereleases of the same prefix order by `compare_prerelease_identifiers`.
fn is_daemon_version_newer(daemon_version: &str, client_version: &str) -> bool {
let daemon = parse_numeric_version_prefix(daemon_version);
let client = parse_numeric_version_prefix(client_version);
for index in 0..daemon.len().max(client.len()) {
- let daemon_segment = daemon.get(index).copied().unwrap_or(0);
- let client_segment = client.get(index).copied().unwrap_or(0);
- if daemon_segment != client_segment {
- return daemon_segment > client_segment;
+ let daemon_segment = daemon.get(index).copied().unwrap_or("0");
+ let client_segment = client.get(index).copied().unwrap_or("0");
+ let ordering = compare_numeric_identifiers(daemon_segment, client_segment);
+ if ordering != Ordering::Equal {
+ return ordering == Ordering::Greater;
+ }
+ }
+ let daemon_ids = prerelease_identifiers(daemon_version);
+ let client_ids = prerelease_identifiers(client_version);
+ match (daemon_ids.is_empty(), client_ids.is_empty()) {
+ (_, true) => false,
+ (true, false) => true,
+ (false, false) => {
+ compare_prerelease_identifiers(&daemon_ids, &client_ids) == Ordering::Greater
}
}
- !has_prerelease_suffix(daemon_version) && has_prerelease_suffix(client_version)
}
-/// The dot- and dash-separated segments of a version ("1.2.3-beta.1" ->
-/// `["1", "2", "3", "beta", "1"]`).
-fn split_version_segments(value: &str) -> Vec<&str> {
- value.split(['.', '-']).collect()
+/// Build metadata never contributes to Semver precedence.
+fn version_without_build(value: &str) -> &str {
+ value.split('+').next().unwrap_or(value)
}
-/// The leading numeric segments; the first unparseable segment ends the
-/// prefix.
-fn parse_numeric_version_prefix(value: &str) -> Vec<u64> {
+/// The leading numeric segments of the release prefix; the first
+/// unparseable segment ends the prefix for nonstandard development versions.
+fn parse_numeric_version_prefix(value: &str) -> Vec<&str> {
+ let release = version_without_build(value)
+ .split('-')
+ .next()
+ .unwrap_or(value);
let mut segments = Vec::new();
- for segment in split_version_segments(value) {
- let Ok(parsed) = segment.parse::<u64>() else {
+ for segment in release.split('.') {
+ if segment.is_empty() || !segment.bytes().all(|byte| byte.is_ascii_digit()) {
break;
- };
- segments.push(parsed);
+ }
+ segments.push(segment);
}
segments
}
-/// Whether the version continues past its numeric prefix with a
-/// prerelease suffix.
-fn has_prerelease_suffix(value: &str) -> bool {
- let segments = split_version_segments(value);
- let prefix_len = parse_numeric_version_prefix(value).len();
- prefix_len > 0 && prefix_len < segments.len()
+/// Prerelease identifiers split on dots only: hyphens belong to an
+/// identifier, and even an entirely numeric prerelease remains a prerelease.
+fn prerelease_identifiers(value: &str) -> Vec<&str> {
+ let value = version_without_build(value);
+ if let Some((_, prerelease)) = value.split_once('-') {
+ return prerelease.split('.').collect();
+ }
+ // Preserve the existing treatment of nonstandard development strings.
+ value
+ .split('.')
+ .skip(parse_numeric_version_prefix(value).len())
+ .collect()
+}
+
+/// Decimal length then lexical order compares arbitrarily large numeric
+/// identifiers, retaining the accepted leading-zero behavior of core versions.
+fn compare_numeric_identifiers(daemon: &str, client: &str) -> Ordering {
+ let daemon_number = daemon.trim_start_matches('0');
+ let client_number = client.trim_start_matches('0');
+ daemon_number
+ .len()
+ .cmp(&client_number.len())
+ .then_with(|| daemon_number.cmp(client_number))
+}
+
+/// Semver §11 ordering of two prerelease identifier lists: identifiers
+/// compare left to right — numeric ones numerically, alphanumeric ones
+/// lexically, numeric below alphanumeric — and the list with more
+/// identifiers wins when the shared ones are equal.
+fn compare_prerelease_identifiers(daemon: &[&str], client: &[&str]) -> Ordering {
+ for (daemon_id, client_id) in daemon.iter().zip(client) {
+ let daemon_numeric = daemon_id.bytes().all(|byte| byte.is_ascii_digit());
+ let client_numeric = client_id.bytes().all(|byte| byte.is_ascii_digit());
+ let ordering = match (daemon_numeric, client_numeric) {
+ (true, true) => compare_numeric_identifiers(daemon_id, client_id),
+ (true, false) => Ordering::Less,
+ (false, true) => Ordering::Greater,
+ (false, false) => daemon_id.cmp(client_id),
+ };
+ if ordering != Ordering::Equal {
+ return ordering;
+ }
+ }
+ daemon.len().cmp(&client.len())
}
#[cfg(test)]
@@ -131,6 +183,59 @@ mod tests {
);
}
+ #[test]
+ fn build_metadata_does_not_change_precedence() {
+ assert!(!is_daemon_version_newer("1.2.3+daemon", "1.2.3+client"));
+ assert!(!is_daemon_version_newer(
+ "1.2.3-beta.1+daemon",
+ "1.2.3-beta.1"
+ ));
+ assert!(is_daemon_version_newer(
+ "1.2.3+daemon",
+ "1.2.3-beta.1+client"
+ ));
+ assert!(is_daemon_version_newer("1.2.4+daemon", "1.2.3+client"));
+ }
+
+ #[test]
+ fn hyphens_belong_to_the_prerelease_identifier() {
+ assert!(is_daemon_version_newer("1.2.3-alpha-2", "1.2.3-alpha-10"));
+ assert!(is_daemon_version_newer("1.2.3-alpha-10", "1.2.3-alpha.10"));
+ assert!(!is_daemon_version_newer("1.2.3-20", "1.2.3"));
+ assert!(!is_daemon_version_newer("1.2.3-20", "1.2.3-alpha"));
+ }
+
+ #[test]
+ fn numeric_prerelease_identifiers_have_no_integer_size_limit() {
+ assert!(is_daemon_version_newer(
+ "1.2.3-beta.100000000000000000000",
+ "1.2.3-beta.99999999999999999999"
+ ));
+ assert!(!is_daemon_version_newer(
+ "1.2.3-beta.100000000000000000000",
+ "1.2.3-beta.alpha"
+ ));
+ }
+
+ #[test]
+ fn numeric_core_segments_have_no_integer_size_limit() {
+ for (newer, older) in [
+ ("100000000000000000000.0.0", "2.0.0"),
+ ("1.100000000000000000000.0", "1.99999999999999999999.0"),
+ ("1.2.100000000000000000000", "1.2.99999999999999999999"),
+ ] {
+ assert!(is_daemon_version_newer(newer, older), "{newer} > {older}");
+ assert!(!is_daemon_version_newer(older, newer), "{older} < {newer}");
+ }
+ assert!(is_daemon_version_newer(
+ "100000000000000000000.0.0",
+ "100000000000000000000.0.0-beta.1"
+ ));
+ assert!(!is_daemon_version_newer("01.002.0003", "1.2.3"));
+ assert!(!is_daemon_version_newer("1.2.0", "1.2"));
+ assert!(!is_daemon_version_newer("1..9", "1.2.0"));
+ }
+
/// TS `isDaemonVersionNewer`: numeric-prefix ordering with the semver prerelease rule.
#[test]
fn the_version_order_follows_the_ts_rules() {
@@ -141,6 +246,7 @@ mod tests {
assert!(!is_daemon_version_newer("1.2.3-beta.1", "1.2.3"));
assert!(!is_daemon_version_newer("1.2.3-beta.2", "1.2.3-beta.10"));
assert!(!is_daemon_version_newer("1.2.3-beta.1", "1.2.3-beta.2"));
+ assert!(is_daemon_version_newer("0.10.1-beta.20", "0.10.1-beta.8"));
// An unparseable version has an empty prefix: it reads as all zeros, so a real release
// orders above it but never below.
assert!(!is_daemon_version_newer("dev", "0.1.0"));
diff --git a/scripts/review_draft_disconnect_parity.py b/scripts/review_draft_disconnect_parity.py
index f40ab2e445..ca0bf43928 100644
--- a/scripts/review_draft_disconnect_parity.py
+++ b/scripts/review_draft_disconnect_parity.py
@@ -387,6 +387,21 @@ class Supervisor:
response["data"] = fixture_state(self.root, active)
with self.lock:
response["data"]["messageCount"] = len(self.messages)
+ elif name == "get_messages":
+ # pa-daemon worker::commands::handle_get_messages and TS
+ # daemon-mode get_messages return the actual transcript.
+ # Fixture turns only append; no branches/pagination are used.
+ with self.lock:
+ response["data"] = {"messages": list(self.messages)}
+ elif name == "get_session_context":
+ # pa-daemon state_getters::handle_get_session_context's
+ # context envelope. This fixture has no compaction or
+ # model/thinking/tier change rows: build_session_context
+ # preserves its turns and uses off/None/None defaults.
+ with self.lock:
+ response["data"] = {"context": {
+ "messages": list(self.messages), "thinkingLevel": "off",
+ "serviceTier": None, "model": None}}
elif name == "get_mcp_connections": response["data"] = {"connections": []}
elif name == "detach": response["data"] = {}
elif name == "set_auto_compaction":
diff --git a/scripts/review_reconnect_version_parity.py b/scripts/review_reconnect_version_parity.py
new file mode 100644
index 0000000000..81efd2b0d1
--- /dev/null
+++ b/scripts/review_reconnect_version_parity.py
@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Compare actual TS/Rust reconnect banners, recording the SemVer correction.
+
+The pinned TS runtime treats an all-numeric suffix as another release segment;
+Rust deliberately corrects that invalid precedence. Raw screens and both actual
+versions are retained. The ordinary post-reconnect command catalog response is
+held until capture because TS resync can erase the transient status before paint.
+This checks version advice, not restart durability. No fake renderer or extracted
+comparator executes here.
+"""
+import argparse
+import errno
+import json
+import os
+from pathlib import Path
+import re
+import socket
+import tempfile
+import threading
+import uuid
+
+from review_draft_disconnect_parity import (Supervisor, Terminal, actual_hello,
+ digest, env_for, fixture_state, TS_ARCHIVE_SHA256)
+
+
+def runtime_version(binary, root, env):
+ import subprocess
+ probe = subprocess.run([str(binary), '--version'], cwd=root, env=env,
+ text=True, capture_output=True, timeout=10, check=True)
+ matches = re.findall(r'\d+\.\d+\.\d+(?:[-+][\w.+-]+)?', probe.stdout)
+ if len(matches) != 1:
+ raise RuntimeError('cannot identify actual runtime version: ' + probe.stdout)
+ return matches[0]
+
+
+class RestartSupervisor(Supervisor):
+ def __init__(self, *args):
+ self.release_catalog = threading.Event()
+ self.catalog_held = threading.Event()
+ super().__init__(*args)
+
+ def send(self, sock, data):
+ if self.closed and data.get('type') == 'response' and data.get('command') == 'get_commands':
+ # TS shows the status before its asynchronous resync rebuild clears
+ # the transcript. Hold that rebuild at its ordinary catalog request
+ # so a real terminal frame can expose the comparator's banner.
+ self.catalog_held.set()
+ if not self.release_catalog.wait(35):
+ raise TimeoutError('restart catalog gate was not released')
+ if data.get('type') == 'response' and data.get('command') in ('attach', 'list'):
+ # Announced restart recovery locates its durable session in list
+ # before attaching it, unlike the ordinary transport EOF path.
+ summary = fixture_state(self.root, 's1')
+ summary.update(id='s1', sessionFile=str(self.root / 'agent/sessions/fixture.jsonl'))
+ if data['command'] == 'attach':
+ payload = dict(data['data'])
+ payload['snapshot'] = dict(payload['snapshot'], summary=summary)
+ data = dict(data, data=payload)
+ else:
+ data = dict(data, data={'sessions': [summary]})
+ super().send(sock, data)
+
+ def restart(self, version):
+ # Both clients reserve the versioned restart banner for an announced
+ # daemon shutdown/update. A bare EOF exercises transport recovery and
+ # emits a different generic reconnect status.
+ with self.lock:
+ connections = [connection for connection in self.sockets if connection.fileno() >= 0]
+ self.hello = dict(self.hello, appVersion=version,
+ supervisorGeneration=str(uuid.uuid4()))
+ self.closed = True
+ for connection in connections:
+ try:
+ self.send(connection, {'type': 'daemon_closing', 'reason': 'shutdown'})
+ self.send(connection, {'type': 'session_closed', 'activeSessionId': 's1',
+ 'reason': 'shutdown'})
+ connection.shutdown(socket.SHUT_RDWR)
+ except OSError as error:
+ if error.errno not in (errno.EBADF, errno.EPIPE, errno.ECONNRESET, errno.ENOTCONN):
+ raise
+
+
+def run_case(kind, binary, root, hello, client, name, observed=None):
+ root.mkdir()
+ env = env_for(root, kind)
+ base = client.split('+')[0].split('-')[0]
+ parts = [int(x) for x in base.split('.')]
+ newer = f'{parts[0] + 1}.0.0'
+ versions = {'same': client, 'newer': newer, 'older': '0.0.0',
+ 'metadata': base + '+fixture', 'numeric_prerelease': base + '-20'}
+ daemon = versions[name]
+ observed = observed if observed is not None else {}
+ observed.update(daemon_version=daemon, client_version=client, executed=False)
+ path = root / 'fixture.sock'
+ fixture_hello = dict(hello, socketPath=str(path), supervisorSocketPath=str(path))
+ server = RestartSupervisor(path, fixture_hello, 'restart', root)
+ terminal = None
+ try:
+ terminal = Terminal([str(binary), '--daemon-socket', str(server.path)], root, env)
+ terminal.wait('initial real TUI attach', lambda: server.attaches >= 1
+ and bool(terminal.screen.text().strip()), server)
+ terminal.send('RECONNECT_VERSION_PARITY')
+ terminal.wait('ordinary prompt editor ready', lambda:
+ 'RECONNECT_VERSION_PARITY' in terminal.screen.text(), server)
+ terminal.send('\r')
+ terminal.wait('initial turn settled through actual TUI subscription', lambda:
+ 'Fixture settled 1' in terminal.screen.text(), server)
+ server.restart(daemon)
+ terminal.wait('reattach banner rendered', lambda: server.post_close_attached
+ and 'Daemon restarted (v' in terminal.screen.text(), server)
+ screen = terminal.screen.text()
+ actual_advice = 'restart the window to pick up the update.' in screen
+ # This explicitly documents the baseline TS defect corrected by #3566.
+ expected_advice = name == 'newer' or (kind == 'ts' and name == 'numeric_prerelease')
+ assert actual_advice == expected_advice, (kind, name, screen)
+ if name == 'same':
+ expected = f'Daemon restarted (v{daemon}) - reconnected'
+ elif expected_advice:
+ expected = (f'Daemon restarted (v{daemon}), this window still runs v{client} '
+ '- restart the window to pick up the update.')
+ else:
+ expected = f'Daemon restarted (v{daemon}), this window runs v{client}.'
+ # Reflow is terminal layout only; all rendered cells and raw bytes are retained.
+ assert expected in ' '.join(screen.split()), (expected, screen)
+ observed.update({'daemon_version': daemon, 'client_version': client,
+ 'restart_advice': actual_advice, 'expected_banner': expected,
+ 'screen': screen, 'raw_ansi': terminal.raw.decode('utf-8', 'replace'),
+ 'wire_commands': server.commands, 'executed': True})
+ return observed
+ except Exception as error:
+ observed['error'] = f'{type(error).__name__}: {error}'
+ raise
+ finally:
+ server.release_catalog.set()
+ observed['resync_catalog_held'] = server.catalog_held.is_set()
+ observed['wire_commands'] = list(server.commands)
+ observed['fixture_errors'] = list(server.errors)
+ observed['post_close_attached'] = server.post_close_attached
+ observed['socket_connection_count'] = len(server.sockets)
+ observed['diagnostic_logs'] = {str(path.relative_to(root)): path.read_text(errors='replace')[-12000:]
+ for path in (root / 'agent/logs').glob('*.log')}
+ if terminal is not None:
+ observed['screen'] = terminal.screen.text()
+ observed['raw_ansi'] = terminal.raw.decode('utf-8', 'replace')
+ if terminal is not None:
+ terminal.close()
+ server.close()
+
+
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--receipt', required=True)
+ args = parser.parse_args()
+ receipt = {'scenario': 'reconnect_version', 'ts_archive_expected_sha256': TS_ARCHIVE_SHA256,
+ 'fixture': 'Announced shutdown/session_closed, durable attach/list identity, successor hello; ordinary resync command catalog response held until actual banner capture.',
+ 'scope': 'Actual rendered version advice; not restart durability or uninterrupted banner visibility.',
+ 'intentional_difference': 'TS interprets numeric prerelease -20 as a release segment; Rust correctly treats it as older than the release.',
+ 'observations': {}, 'passed': False}
+ try:
+ receipt['ts_archive_sha256'] = digest(Path(os.environ['PA_TS_ARCHIVE']))
+ assert receipt['ts_archive_sha256'] == TS_ARCHIVE_SHA256
+ with tempfile.TemporaryDirectory(prefix='pa-reconnect-parity-', dir='/tmp') as temp:
+ for kind, variable in (('ts', 'PA_TS_BINARY'), ('rust', 'PA_RUST_BINARY')):
+ binary = Path(os.environ[variable]).resolve()
+ root = Path(temp) / kind
+ root.mkdir()
+ env = env_for(root, kind)
+ client = runtime_version(binary, root, env)
+ # Fixture expects current stable binaries; prerelease algorithm edges
+ # are separately covered by red-first exact production-module tests.
+ assert '-' not in client and '+' not in client, client
+ hello = actual_hello(binary, root, env)
+ receipt['observations'][kind] = {'binary_sha256': digest(binary),
+ 'actual_hello': hello, 'client_version': client,
+ 'cases': {}}
+ for name in ('same', 'newer', 'older', 'metadata', 'numeric_prerelease'):
+ observed = receipt['observations'][kind]['cases'][name] = {}
+ run_case(kind, binary, root / name, hello, client, name, observed)
+ ts, rust = (receipt['observations'][kind]['cases'] for kind in ('ts', 'rust'))
+ for name in ('same', 'newer', 'older', 'metadata'):
+ assert ts[name]['restart_advice'] == rust[name]['restart_advice'], name
+ assert ts['numeric_prerelease']['restart_advice'] is True
+ assert rust['numeric_prerelease']['restart_advice'] is False
+ receipt['passed'] = True
+ except Exception as error:
+ receipt['error'] = f'{type(error).__name__}: {error}'
+ Path(args.receipt).parent.mkdir(parents=True, exist_ok=True)
+ Path(args.receipt).write_text(json.dumps(receipt, indent=2) + '\n')
+ print(json.dumps({'scenario': receipt['scenario'], 'passed': receipt['passed'],
+ 'error': receipt.get('error')}))
+ return 0 if receipt['passed'] else 1
+
+
+if __name__ == '__main__':
+ raise SystemExit(main())
diff --git a/scripts/test_review_reconnect_version_parity.py b/scripts/test_review_reconnect_version_parity.py
new file mode 100644
index 0000000000..2e6c6609ab
--- /dev/null
+++ b/scripts/test_review_reconnect_version_parity.py
@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Check the restart fixture's durable identity and observable resync gate."""
+import json
+from pathlib import Path
+import socket
+import threading
+import tempfile
+import unittest
+
+from review_reconnect_version_parity import RestartSupervisor
+
+
+class Connection:
+ def __init__(self, descriptor=4):
+ self.descriptor = descriptor
+ self.frames = []
+ self.shutdowns = []
+
+ def fileno(self):
+ return self.descriptor
+
+ def sendall(self, data):
+ self.frames.append(json.loads(data))
+
+ def shutdown(self, how):
+ self.shutdowns.append(how)
+
+
+def fixture():
+ server = object.__new__(RestartSupervisor)
+ server.root = Path('/tmp/reconnect-fixture')
+ server.closed = False
+ server.hello = {'appVersion': '0.9.8', 'protocol': {'version': 7}}
+ server.lock = threading.Lock()
+ server.sockets = []
+ server.release_catalog = threading.Event()
+ server.catalog_held = threading.Event()
+ return server
+
+
+class RestartFixtureTests(unittest.TestCase):
+ def test_snapshot_reads_preserve_the_settled_fixture_turn(self):
+ with tempfile.TemporaryDirectory(prefix='reconnect-read-', dir='/tmp') as folder:
+ root = Path(folder)
+ server = RestartSupervisor(root / 'd.sock',
+ {'type': 'daemon_hello', 'protocol': {'name': 'prime-agent.daemon', 'version': 7}},
+ 'restart', root)
+ try:
+ server.prompts.append({'message': 'persisted fixture prompt'})
+ server.settle(Connection(), 's1', ('fixture', 'turn'), 1, emit=False)
+ with socket.socket(socket.AF_UNIX) as connection:
+ connection.settimeout(2)
+ connection.connect(str(server.path))
+ with connection.makefile('rb') as stream:
+ self.assertEqual(json.loads(stream.readline())['type'], 'daemon_hello')
+ for ident, command, expected in (
+ ('1', 'get_messages', {'messages': server.messages}),
+ ('2', 'get_session_context', {'context': {
+ 'messages': server.messages, 'thinkingLevel': 'off',
+ 'serviceTier': None, 'model': None}}),
+ ):
+ envelope = {'type': 'command', 'id': ident,
+ 'command': {'type': command, 'activeSessionId': 's1'}}
+ connection.sendall((json.dumps(envelope) + '\n').encode())
+ response = json.loads(stream.readline())
+ self.assertTrue(response['success'], response)
+ self.assertEqual(response['data'], expected)
+ self.assertEqual(len(server.messages), 2)
+ self.assertEqual(server.errors, [])
+ finally:
+ server.close()
+
+ def test_attach_and_list_share_the_durable_session_identity(self):
+ server, connection = fixture(), Connection()
+ server.send(connection, {'type': 'response', 'command': 'attach',
+ 'data': {'snapshot': {'summary': {'id': 's1'}, 'state': {'sessionId': 'fixture-durable'}}}})
+ server.send(connection, {'type': 'response', 'command': 'list', 'data': {'sessions': []}})
+ attached = connection.frames[0]['data']['snapshot']['summary']
+ listed = connection.frames[1]['data']['sessions'][0]
+ self.assertEqual(attached, listed)
+ self.assertEqual(attached['sessionId'], 'fixture-durable')
+ self.assertEqual(attached['activeSessionId'], 's1')
+ self.assertTrue(attached['sessionFile'].endswith('/sessions/fixture.jsonl'))
+
+ def test_restart_announces_shutdown_before_closing_only_live_connections(self):
+ server = fixture()
+ live, closed = Connection(), Connection(-1)
+ server.sockets = [live, closed]
+ server.restart('0.10.0')
+ self.assertEqual(live.frames, [
+ {'type': 'daemon_closing', 'reason': 'shutdown'},
+ {'type': 'session_closed', 'activeSessionId': 's1', 'reason': 'shutdown'}])
+ self.assertEqual(live.shutdowns, [socket.SHUT_RDWR])
+ self.assertEqual(closed.frames, [])
+ self.assertEqual(server.hello['appVersion'], '0.10.0')
+ self.assertEqual(server.hello['protocol'], {'version': 7})
+ self.assertTrue(server.hello['supervisorGeneration'])
+
+ def test_restarted_catalog_response_waits_for_capture_release(self):
+ server, connection = fixture(), Connection()
+ server.closed = True
+ response = {'type': 'response', 'command': 'get_commands', 'data': {'commands': []}}
+ thread = threading.Thread(target=server.send, args=(connection, response), daemon=True)
+ thread.start()
+ try:
+ self.assertTrue(server.catalog_held.wait(2))
+ self.assertEqual(connection.frames, [])
+ finally:
+ server.release_catalog.set()
+ thread.join(2)
+ self.assertFalse(thread.is_alive())
+ self.assertEqual(connection.frames, [response])
+
+
+if __name__ == '__main__':
+ unittest.main()