Projects / Atlas / Chrome release
-
Release candidate 0.2.1
Production reliability hotfix validation.
+
Isolated UI fixture
Layout validation only — not a live agent result.
Ready for review
diff --git a/tests/test_broker.py b/tests/test_broker.py
index 7116827..d24e6c4 100644
--- a/tests/test_broker.py
+++ b/tests/test_broker.py
@@ -440,6 +440,53 @@ async def test_reconnect_with_same_browser_id_cancels_old_pending_action(self):
fresh = await receive_type(chrome_new, "action")
self.assertEqual(fresh["targetTabId"], 22)
+ async def test_invalid_reconnect_nonce_cannot_evict_live_browser(self):
+ live_socket = await self.browser("stable-browser", "Live browser")
+ live_peer = self.server.browsers["stable-browser"]
+ candidate = await websockets.connect(
+ self.url, origin="chrome-extension://unit-test/"
+ )
+ self.clients.append(candidate)
+ challenge = json.loads(await candidate.recv())
+ await candidate.send(json.dumps({
+ "type": "hello",
+ "role": "browser",
+ "browserId": "stable-browser",
+ "browserName": "Invalid replacement",
+ "nonce": "!",
+ "proof": broker.role_proof(
+ self.secret, "browser", "stable-browser", challenge["nonce"]
+ ),
+ "protocol": broker.PROTOCOL_VERSION,
+ }))
+ with self.assertRaises(websockets.exceptions.ConnectionClosed):
+ await candidate.recv()
+ self.assertIs(self.server.browsers.get("stable-browser"), live_peer)
+ await live_socket.send(json.dumps({"type": "keepalive"}))
+
+ async def test_invalid_reconnect_nonce_cannot_evict_live_agent(self):
+ live_socket = await self.agent("alpha", "stable-process")
+ live_peer = self.server.agents["alpha:stable-process"]
+ candidate = await websockets.connect(self.url)
+ self.clients.append(candidate)
+ challenge = json.loads(await candidate.recv())
+ client_id = "alpha:stable-process"
+ await candidate.send(json.dumps({
+ "type": "hello",
+ "role": "agent",
+ "profileId": "alpha",
+ "processId": "stable-process",
+ "nonce": "!",
+ "proof": broker.role_proof(
+ self.secret, "agent", client_id, challenge["nonce"]
+ ),
+ "protocol": broker.PROTOCOL_VERSION,
+ }))
+ with self.assertRaises(websockets.exceptions.ConnectionClosed):
+ await candidate.recv()
+ self.assertIs(self.server.agents.get("alpha:stable-process"), live_peer)
+ await live_socket.send(json.dumps({"type": "keepalive"}))
+
async def test_stale_browser_cannot_mutate_after_waiting_for_binding_lock(self):
chrome_old = await self.browser("stable-browser", "First connection")
old_peer = self.server.browsers["stable-browser"]
@@ -648,6 +695,67 @@ async def test_sync_client_forwards_real_profile_and_session(self):
result = await result_task
self.assertTrue(result["ok"])
self.assertEqual(result["data"], {"snapshot": "ok"})
+ self.assertNotIn("error", result)
+
+
+class BridgeClientResponseShapeTests(unittest.TestCase):
+ def test_request_success_omits_error_key(self):
+ with tempfile.TemporaryDirectory() as temp:
+ client = bridge_client.BridgeClient(
+ profile_id="response-shape-profile",
+ root=temp,
+ auto_start_broker=False,
+ )
+ broker_response = {
+ "ok": True,
+ "data": {"text": "ready"},
+ "error": None,
+ }
+ with mock.patch.object(client, "_call", return_value=broker_response):
+ result = client.request(
+ {"kind": "read_text"},
+ session_id="response-shape-session",
+ )
+
+ self.assertEqual(result, {"ok": True, "data": {"text": "ready"}})
+ self.assertNotIn("error", result)
+
+ def test_request_failure_has_false_ok_and_error(self):
+ cases = (
+ ({"ok": False, "error": "Browser action failed"}, "Browser action failed"),
+ ({"ok": False, "error": None}, "Connector request failed"),
+ )
+ for broker_response, expected_error in cases:
+ with self.subTest(broker_response=broker_response), \
+ tempfile.TemporaryDirectory() as temp:
+ client = bridge_client.BridgeClient(
+ profile_id="response-shape-profile",
+ root=temp,
+ auto_start_broker=False,
+ )
+ with mock.patch.object(
+ client, "_call", return_value=broker_response
+ ):
+ result = client.request(
+ {"kind": "snapshot"},
+ session_id="response-shape-session",
+ )
+
+ self.assertIs(result["ok"], False)
+ self.assertEqual(result["error"], expected_error)
+ self.assertNotIn("data", result)
+
+ def test_status_omits_error_until_a_real_error_exists(self):
+ with tempfile.TemporaryDirectory() as temp:
+ client = bridge_client.BridgeClient(
+ profile_id="response-shape-profile",
+ root=temp,
+ auto_start_broker=False,
+ )
+ self.assertNotIn("error", client.status())
+
+ client.last_error = "Broker unavailable"
+ self.assertEqual(client.status()["error"], "Broker unavailable")
class BridgeClientLifecycleTests(unittest.TestCase):
diff --git a/tests/test_installer.py b/tests/test_installer.py
index 41d3937..d68f2a1 100644
--- a/tests/test_installer.py
+++ b/tests/test_installer.py
@@ -140,6 +140,119 @@ def test_shared_home_and_existing_profiles_receive_the_plugin(self):
self.assertTrue((target / "plugin.yaml").is_file())
self.assertFalse((ignored / "plugins" / installer.PLUGIN_NAME).exists())
+ def test_multi_profile_install_replaces_stale_021_payload_byte_for_byte(self):
+ """A 0.2.1 label must not hide a protocol-v3 broker in any profile."""
+
+ with tempfile.TemporaryDirectory() as temp:
+ root = Path(temp) / "hermes"
+ profiles = [
+ root / "profiles" / "personal",
+ root / "profiles" / "work",
+ ]
+ for profile in profiles:
+ profile.mkdir(parents=True)
+ (profile / "config.yaml").write_text(
+ "plugins:\n enabled: []\n", encoding="utf-8"
+ )
+
+ source = ROOT / "hermes-plugin"
+ expected_homes = [root.resolve(), *(profile.resolve() for profile in profiles)]
+ for home in expected_homes:
+ target = home / "plugins" / installer.PLUGIN_NAME
+ target.mkdir(parents=True)
+ for name in installer.PLUGIN_FILES:
+ (target / name).write_bytes(f"stale payload: {name}\n".encode("utf-8"))
+ (target / "plugin.yaml").write_text(
+ "name: hermes-connector\nversion: 0.2.1\n", encoding="utf-8"
+ )
+ (target / "broker.py").write_text(
+ "PROTOCOL_VERSION = 3\nDEFAULT_PORT = 8765\n", encoding="utf-8"
+ )
+ (target / "stale-only.txt").write_text("remove me", encoding="utf-8")
+
+ result = installer.main([
+ "--hermes-home", str(root),
+ "--source", str(source),
+ "--no-enable",
+ "--no-show-code",
+ ])
+
+ self.assertEqual(result, 0)
+ self.assertEqual(installer.installation_homes(root), expected_homes)
+ source_bytes = {
+ name: (source / name).read_bytes() for name in installer.PLUGIN_FILES
+ }
+ for home in expected_homes:
+ target = home / "plugins" / installer.PLUGIN_NAME
+ self.assertEqual(
+ {path.name for path in target.iterdir() if path.is_file()},
+ set(installer.PLUGIN_FILES),
+ )
+ for name, expected in source_bytes.items():
+ with self.subTest(home=home, payload=name):
+ self.assertEqual((target / name).read_bytes(), expected)
+
+ installed_manifest = (target / "plugin.yaml").read_text(encoding="utf-8")
+ installed_broker = (target / "broker.py").read_text(encoding="utf-8")
+ self.assertRegex(installed_manifest, r"(?m)^version:\s*0\.2\.2\s*$")
+ self.assertRegex(installed_broker, r"(?m)^PROTOCOL_VERSION\s*=\s*4\s*$")
+ self.assertRegex(installed_broker, r"(?m)^DEFAULT_PORT\s*=\s*8766\s*$")
+
+ def test_release_version_protocol_and_port_contract_is_consistent(self):
+ plugin_source = (ROOT / "hermes-plugin" / "plugin.yaml").read_text(
+ encoding="utf-8"
+ )
+ broker_source = (ROOT / "hermes-plugin" / "broker.py").read_text(
+ encoding="utf-8"
+ )
+ bridge_client_source = (ROOT / "hermes-plugin" / "bridge_client.py").read_text(
+ encoding="utf-8"
+ )
+ extension_manifest = json.loads(
+ (ROOT / "extension" / "manifest.json").read_text(encoding="utf-8")
+ )
+ extension_protocol = (ROOT / "extension" / "src" / "protocol.js").read_text(
+ encoding="utf-8"
+ )
+
+ plugin_version = re.search(r"(?m)^version:\s*([^\s]+)\s*$", plugin_source)
+ broker_protocol = re.search(
+ r"(?m)^PROTOCOL_VERSION\s*=\s*(\d+)\s*$", broker_source
+ )
+ broker_port = re.search(r"(?m)^DEFAULT_PORT\s*=\s*(\d+)\s*$", broker_source)
+ extension_protocol_version = re.search(
+ r"PROTOCOL_VERSION\s*=\s*(\d+)", extension_protocol
+ )
+ extension_port = re.search(
+ r'DEFAULT_BRIDGE_URL\s*=\s*"ws://127\.0\.0\.1:(\d+)/?"',
+ extension_protocol,
+ )
+
+ for label, match in (
+ ("plugin version", plugin_version),
+ ("broker protocol", broker_protocol),
+ ("broker port", broker_port),
+ ("extension protocol", extension_protocol_version),
+ ("extension port", extension_port),
+ ):
+ with self.subTest(contract=label):
+ self.assertIsNotNone(match, f"missing {label} declaration")
+
+ self.assertEqual(extension_manifest["version"], "0.2.2")
+ self.assertEqual(plugin_version.group(1), extension_manifest["version"])
+ self.assertEqual(int(broker_protocol.group(1)), 4)
+ self.assertEqual(int(extension_protocol_version.group(1)), 4)
+ self.assertEqual(broker_protocol.group(1), extension_protocol_version.group(1))
+ self.assertEqual(int(broker_port.group(1)), 8766)
+ self.assertEqual(broker_port.group(1), extension_port.group(1))
+ self.assertIn("broker.PROTOCOL_VERSION", bridge_client_source)
+ self.assertIn("broker.DEFAULT_PORT", bridge_client_source)
+
+ payload_files = {
+ path.name for path in (ROOT / "hermes-plugin").iterdir() if path.is_file()
+ }
+ self.assertEqual(set(installer.PLUGIN_FILES), payload_files)
+
def test_profiles_directory_symlink_is_rejected_without_touching_destination(self):
with tempfile.TemporaryDirectory() as temp:
root = Path(temp) / "hermes"
@@ -168,9 +281,9 @@ def test_profiles_directory_junction_is_rejected_without_touching_destination(se
work.mkdir(parents=True)
marker = work / "config.yaml"
marker.write_text("plugins:\n enabled: [keep]\n", encoding="utf-8")
- junction = root / "profiles"
+ profiles = root / "profiles"
created = subprocess.run(
- ["cmd.exe", "/d", "/c", "mklink", "/J", str(junction), str(destination)],
+ ["cmd.exe", "/d", "/c", "mklink", "/J", str(profiles), str(destination)],
capture_output=True,
text=True,
)
@@ -180,7 +293,7 @@ def test_profiles_directory_junction_is_rejected_without_touching_destination(se
with self.assertRaisesRegex(RuntimeError, "unsafe Hermes profiles directory"):
installer.installation_homes(root)
finally:
- os.rmdir(junction)
+ os.rmdir(profiles)
self.assertEqual(marker.read_text(encoding="utf-8"), "plugins:\n enabled: [keep]\n")
def test_enable_uses_the_exact_profile_home(self):
@@ -311,6 +424,55 @@ def test_install_is_atomic_and_preserves_previous_copy(self):
self.assertEqual((previous2 / "local-note.txt").read_text(encoding="utf-8"), "preserve me")
self.assertFalse((target2 / "local-note.txt").exists())
+ def test_verification_failure_after_publish_restores_exact_previous_payload(self):
+ with tempfile.TemporaryDirectory() as temp:
+ home = Path(temp) / "hermes"
+ plugins = home / "plugins"
+ target = plugins / installer.PLUGIN_NAME
+ nested = target / "legacy-data"
+ nested.mkdir(parents=True)
+ (target / "plugin.yaml").write_bytes(b"old manifest\r\nversion: 0.1.0\r\n")
+ (target / "legacy-only.bin").write_bytes(b"\x00old companion\xff")
+ (nested / "keep.dat").write_bytes(b"exact nested bytes\x00")
+
+ def snapshot_tree(root):
+ return {
+ path.relative_to(root).as_posix(): (
+ None if path.is_dir() else path.read_bytes()
+ )
+ for path in root.rglob("*")
+ }
+
+ previous_snapshot = snapshot_tree(target)
+
+ def reject_published_payload(source, published_target):
+ self.assertTrue(published_target.samefile(target))
+ self.assertEqual(
+ {path.name for path in published_target.iterdir() if path.is_file()},
+ set(installer.PLUGIN_FILES),
+ )
+ for name in installer.PLUGIN_FILES:
+ self.assertEqual(
+ (published_target / name).read_bytes(),
+ (source / name).read_bytes(),
+ )
+ raise RuntimeError("simulated post-publication verification failure")
+
+ with mock.patch.object(
+ installer,
+ "verify_installed_payload",
+ side_effect=reject_published_payload,
+ ) as verify:
+ with self.assertRaisesRegex(RuntimeError, "post-publication"):
+ installer.install(ROOT / "hermes-plugin", home)
+
+ verify.assert_called_once()
+ self.assertEqual(snapshot_tree(target), previous_snapshot)
+ self.assertEqual(
+ {path.name for path in plugins.iterdir()},
+ {installer.PLUGIN_NAME},
+ )
+
def test_keyboard_interrupt_between_payload_swaps_restores_previous_copy(self):
with tempfile.TemporaryDirectory() as temp:
home = Path(temp) / "hermes"
diff --git a/tests/test_plugin_routing.py b/tests/test_plugin_routing.py
index 40f217a..c82c0de 100644
--- a/tests/test_plugin_routing.py
+++ b/tests/test_plugin_routing.py
@@ -95,6 +95,30 @@ def test_obsolete_disk_profile_tools_are_not_registered(self):
self.assertNotIn("bridge_pin", self.context.tools)
self.assertIn("bridge_tab", self.context.tools)
+ def test_bridge_status_success_has_no_false_error_key(self):
+ result = json.loads(
+ self.context.tools["bridge_status"]["handler"]({})
+ )
+
+ self.assertIs(result["ok"], True)
+ self.assertEqual(result["bridge"], {
+ "connected": True,
+ "profile": "real-profile",
+ })
+ self.assertNotIn("error", result)
+ self.assertNotIn("error", result["bridge"])
+
+ def test_bridge_status_reports_unregistered_plugin(self):
+ plugin.BRIDGE = None
+
+ result = json.loads(
+ self.context.tools["bridge_status"]["handler"]({})
+ )
+
+ self.assertIs(result["ok"], False)
+ self.assertEqual(result["error"], "Connector plugin is not registered")
+ self.assertNotIn("bridge", result)
+
def test_reregister_stops_the_previous_companion_client(self):
first = self.client
replacement_context = FakeContext()
diff --git a/tests/test_windows_broker_launch.py b/tests/test_windows_broker_launch.py
new file mode 100644
index 0000000..253cc32
--- /dev/null
+++ b/tests/test_windows_broker_launch.py
@@ -0,0 +1,204 @@
+"""Regression coverage for the Windows broker-launch defects reported in #5."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import importlib.util
+import os
+from pathlib import Path
+import queue
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import types
+import unittest
+from unittest import mock
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PLUGIN = ROOT / "hermes-plugin"
+PACKAGE_NAME = "hermes_connector_windows_launch_tests"
+PACKAGE = types.ModuleType(PACKAGE_NAME)
+PACKAGE.__path__ = [str(PLUGIN)]
+sys.modules[PACKAGE_NAME] = PACKAGE
+
+BROKER_SPEC = importlib.util.spec_from_file_location(
+ f"{PACKAGE_NAME}.broker", PLUGIN / "broker.py"
+)
+broker = importlib.util.module_from_spec(BROKER_SPEC)
+assert BROKER_SPEC and BROKER_SPEC.loader
+sys.modules[BROKER_SPEC.name] = broker
+BROKER_SPEC.loader.exec_module(broker)
+
+CLIENT_SPEC = importlib.util.spec_from_file_location(
+ f"{PACKAGE_NAME}.bridge_client", PLUGIN / "bridge_client.py"
+)
+bridge_client = importlib.util.module_from_spec(CLIENT_SPEC)
+assert CLIENT_SPEC and CLIENT_SPEC.loader
+sys.modules[CLIENT_SPEC.name] = bridge_client
+CLIENT_SPEC.loader.exec_module(bridge_client)
+
+
+class FakeProcess:
+ returncode = None
+
+ def poll(self):
+ return self.returncode
+
+
+class WindowsBrokerLaunchTests(unittest.TestCase):
+ def test_windows_launch_uses_hidden_console_without_detached_process(self):
+ with tempfile.TemporaryDirectory() as temp:
+ client = bridge_client.BridgeClient("default", root=temp)
+ captured = {}
+
+ def fake_popen(command, **kwargs):
+ captured["command"] = command
+ captured["kwargs"] = kwargs
+ return FakeProcess()
+
+ log_stream = mock.MagicMock()
+ with (
+ mock.patch.object(bridge_client.sys, "platform", "win32"),
+ mock.patch.object(
+ bridge_client.subprocess, "CREATE_NEW_PROCESS_GROUP", 0x00000200,
+ create=True,
+ ),
+ mock.patch.object(
+ bridge_client.subprocess, "CREATE_NO_WINDOW", 0x08000000,
+ create=True,
+ ),
+ mock.patch.object(
+ bridge_client.subprocess, "DETACHED_PROCESS", 0x00000008,
+ create=True,
+ ),
+ mock.patch.object(client, "_port_claimed", return_value=False),
+ mock.patch.object(client, "_port_accepting", return_value=True),
+ mock.patch.object(bridge_client, "_open_broker_log", return_value=log_stream),
+ mock.patch.object(bridge_client.subprocess, "Popen", side_effect=fake_popen),
+ ):
+ client._ensure_broker_process()
+
+ flags = captured["kwargs"]["creationflags"]
+ self.assertEqual(flags, 0x08000200)
+ self.assertFalse(flags & 0x00000008)
+ self.assertIs(captured["kwargs"]["stdout"], log_stream)
+ self.assertIs(captured["kwargs"]["stderr"], log_stream)
+ log_stream.close.assert_called_once_with()
+ self.assertEqual(Path(captured["command"][1]).name, "broker.py")
+ self.assertIn("--serve", captured["command"])
+
+ def test_readiness_probe_performs_valid_websocket_upgrade(self):
+ with tempfile.TemporaryDirectory() as temp:
+ listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ self.addCleanup(listener.close)
+ listener.bind(("127.0.0.1", 0))
+ listener.listen(1)
+ port = listener.getsockname()[1]
+ requests: queue.Queue[bytes] = queue.Queue()
+
+ def serve_once():
+ conn, _ = listener.accept()
+ with conn:
+ conn.settimeout(2)
+ request = bytearray()
+ while b"\r\n\r\n" not in request:
+ chunk = conn.recv(1024)
+ if not chunk:
+ break
+ request.extend(chunk)
+ requests.put(bytes(request))
+ headers = {}
+ for line in bytes(request).split(b"\r\n")[1:]:
+ if b":" in line:
+ name, value = line.split(b":", 1)
+ headers[name.strip().lower()] = value.strip()
+ key = headers[b"sec-websocket-key"]
+ accept = base64.b64encode(hashlib.sha1(
+ key + b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+ ).digest())
+ conn.sendall(
+ b"HTTP/1.1 101 Switching Protocols\r\n"
+ b"Upgrade: websocket\r\n"
+ b"Connection: Upgrade\r\n"
+ b"Sec-WebSocket-Accept: " + accept + b"\r\n\r\n"
+ )
+
+ thread = threading.Thread(target=serve_once, daemon=True)
+ thread.start()
+ client = bridge_client.BridgeClient(
+ "default", root=temp, host="127.0.0.1", port=port,
+ auto_start_broker=False,
+ )
+ self.assertTrue(client._port_accepting())
+ thread.join(timeout=2)
+ self.assertFalse(thread.is_alive())
+ request = requests.get(timeout=1)
+ self.assertTrue(request.startswith(b"GET / HTTP/1.1\r\n"))
+ self.assertIn(b"Upgrade: websocket\r\n", request)
+ self.assertIn(b"Connection: Upgrade\r\n", request)
+ self.assertIn(b"Sec-WebSocket-Version: 13\r\n", request)
+
+ def test_concurrent_inherited_append_handles_preserve_all_records(self):
+ with tempfile.TemporaryDirectory() as temp:
+ temp_path = Path(temp)
+ log_path = temp_path / "broker.log"
+ start_path = temp_path / "start"
+ seed = [f"seed:{index:04d}" for index in range(40)]
+ log_path.write_text("\n".join(seed) + "\n", encoding="utf-8")
+ child = r'''
+from pathlib import Path
+import sys
+import time
+start = Path(sys.argv[1])
+while not start.exists():
+ time.sleep(0.001)
+prefix = sys.argv[2]
+count = int(sys.argv[3])
+for index in range(count):
+ stream = sys.stdout if index % 2 == 0 else sys.stderr
+ stream.write(f"{prefix}:{index:04d}\n")
+ stream.flush()
+'''
+ count = 400
+ streams = [
+ bridge_client._open_broker_log(log_path),
+ bridge_client._open_broker_log(log_path),
+ ]
+ self.assertNotEqual(streams[0].fileno(), streams[1].fileno())
+ processes = []
+ try:
+ for prefix, stream in zip(("writer-a", "writer-b"), streams):
+ processes.append(subprocess.Popen(
+ [sys.executable, "-c", child, str(start_path), prefix, str(count)],
+ stdin=subprocess.DEVNULL,
+ stdout=stream,
+ stderr=stream,
+ close_fds=True,
+ cwd=ROOT,
+ ))
+ finally:
+ for stream in streams:
+ stream.close()
+
+ time.sleep(0.05)
+ start_path.touch()
+ for process in processes:
+ self.assertEqual(process.wait(timeout=15), 0)
+
+ lines = log_path.read_text(encoding="utf-8").splitlines()
+ expected = seed + [
+ f"{prefix}:{index:04d}"
+ for prefix in ("writer-a", "writer-b")
+ for index in range(count)
+ ]
+ self.assertEqual(len(lines), len(expected))
+ self.assertEqual(set(lines), set(expected))
+
+
+if __name__ == "__main__":
+ unittest.main()