Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /amabito_veronica /tests /test_buffered_emitter.py
| # tests/test_buffered_emitter.py | |
| """Tests for veronica.buffered_emitter -- ring buffer event emitter.""" | |
| from __future__ import annotations | |
| import threading | |
| import time | |
| import pytest | |
| from veronica.buffered_emitter import BufferedEmitter | |
| class TestBufferedEmitter: | |
| def test_emit_stores_event(self) -> None: | |
| emitter = BufferedEmitter() | |
| emitter.emit("step_completed", {"step_id": "s1"}) | |
| events = emitter.snapshot() | |
| assert len(events) == 1 | |
| assert events[0] == ("step_completed", {"step_id": "s1"}) | |
| def test_ring_buffer_maxlen(self) -> None: | |
| emitter = BufferedEmitter(maxlen=3) | |
| for i in range(5): | |
| emitter.emit("e", {"i": i}) | |
| events = emitter.snapshot() | |
| assert len(events) == 3 | |
| assert events[0][1]["i"] == 2 # oldest kept | |
| def test_drain_removes_events(self) -> None: | |
| emitter = BufferedEmitter() | |
| emitter.emit("a", {}) | |
| emitter.emit("b", {}) | |
| emitter.emit("c", {}) | |
| drained = emitter.drain(2) | |
| assert len(drained) == 2 | |
| assert drained[0][0] == "a" | |
| assert drained[1][0] == "b" | |
| remaining = emitter.snapshot() | |
| assert len(remaining) == 1 | |
| def test_subscriber_receives_events(self) -> None: | |
| emitter = BufferedEmitter() | |
| received: list[tuple[str, dict]] = [] | |
| emitter.subscribe("test_sub", lambda et, p: received.append((et, p))) | |
| emitter.emit("x", {"val": 1}) | |
| assert len(received) == 1 | |
| assert received[0] == ("x", {"val": 1}) | |
| def test_unsubscribe(self) -> None: | |
| emitter = BufferedEmitter() | |
| received: list = [] | |
| emitter.subscribe("test_sub", lambda et, p: received.append(1)) | |
| emitter.unsubscribe("test_sub") | |
| emitter.emit("x", {}) | |
| assert len(received) == 0 | |
| def test_auto_unsubscribe_after_3_failures(self) -> None: | |
| emitter = BufferedEmitter() | |
| def bad_callback(et: str, p: dict) -> None: | |
| raise RuntimeError("boom") | |
| emitter.subscribe("bad", bad_callback) | |
| for _ in range(3): | |
| emitter.emit("e", {}) | |
| # After 3 failures, subscriber should be gone | |
| assert "bad" not in emitter._subscribers | |
| def test_snapshot_is_nondestructive(self) -> None: | |
| emitter = BufferedEmitter() | |
| emitter.emit("a", {}) | |
| snap1 = emitter.snapshot() | |
| snap2 = emitter.snapshot() | |
| assert snap1 == snap2 | |
| assert len(emitter.snapshot()) == 1 | |
| def test_emit_protocol_compatible(self) -> None: | |
| """Satisfies EventEmitterProtocol.""" | |
| from veronica.protocols import EventEmitterProtocol | |
| emitter = BufferedEmitter() | |
| assert isinstance(emitter, EventEmitterProtocol) | |
| def test_dropped_total_counts_overflow(self) -> None: | |
| """emit 5 events into maxlen=2 buffer -- dropped_total == 3.""" | |
| emitter = BufferedEmitter(maxlen=2) | |
| for i in range(5): | |
| emitter.emit("e", {"i": i}) | |
| assert emitter.dropped_total == 3 | |
| class TestBufferedEmitterThreadSafety: | |
| def test_concurrent_emit(self) -> None: | |
| """10 threads emit simultaneously -- no data corruption.""" | |
| emitter = BufferedEmitter() | |
| barrier = threading.Barrier(10) | |
| def worker(idx: int) -> None: | |
| barrier.wait() | |
| emitter.emit("e", {"idx": idx}) | |
| threads = [threading.Thread(target=worker, args=(i,)) for i in range(10)] | |
| for t in threads: | |
| t.start() | |
| for t in threads: | |
| t.join() | |
| events = emitter.snapshot() | |
| assert len(events) == 10 | |
| indices = sorted(e[1]["idx"] for e in events) | |
| assert indices == list(range(10)) | |
| def test_reentrant_emit_from_subscriber(self) -> None: | |
| """Subscriber calling emit() inside callback -- no deadlock.""" | |
| emitter = BufferedEmitter() | |
| inner_called = threading.Event() | |
| def reentrant_callback(et: str, p: dict) -> None: | |
| if et == "outer": | |
| emitter.emit("inner", {"from": "callback"}) | |
| inner_called.set() | |
| emitter.subscribe("reentrant", reentrant_callback) | |
| emitter.emit("outer", {}) | |
| assert inner_called.is_set() | |
| events = emitter.snapshot() | |
| types = [e[0] for e in events] | |
| assert "outer" in types | |
| assert "inner" in types | |
| def test_slow_subscriber_does_not_block_others(self) -> None: | |
| """Slow subscriber doesn't prevent other subscribers from being called.""" | |
| emitter = BufferedEmitter() | |
| fast_received = threading.Event() | |
| def slow_callback(et: str, p: dict) -> None: | |
| time.sleep(0.1) | |
| def fast_callback(et: str, p: dict) -> None: | |
| fast_received.set() | |
| emitter.subscribe("slow", slow_callback) | |
| emitter.subscribe("fast", fast_callback) | |
| emitter.emit("test", {}) | |
| assert fast_received.is_set() | |
| def test_subscribe_during_emit(self) -> None: | |
| """subscribe/unsubscribe from another thread during emit -- no crash.""" | |
| emitter = BufferedEmitter() | |
| results: list[bool] = [] | |
| def slow_callback(et: str, p: dict) -> None: | |
| time.sleep(0.05) | |
| emitter.subscribe("slow", slow_callback) | |
| def subscribe_thread() -> None: | |
| time.sleep(0.01) # mid-emit | |
| emitter.subscribe("late", lambda et, p: None) | |
| results.append(True) | |
| t = threading.Thread(target=subscribe_thread) | |
| t.start() | |
| emitter.emit("test", {}) | |
| t.join() | |
| assert results == [True] | |
| def test_fatal_exception_propagates(self) -> None: | |
| """SystemExit/KeyboardInterrupt from subscriber propagates.""" | |
| emitter = BufferedEmitter() | |
| emitter.subscribe( | |
| "fatal", lambda et, p: (_ for _ in ()).throw(KeyboardInterrupt) | |
| ) | |
| with pytest.raises(KeyboardInterrupt): | |
| emitter.emit("test", {}) | |
Xet Storage Details
- Size:
- 5.98 kB
- Xet hash:
- 4cb7a1e2d0c6a9d074c790f256549c8a19009ef83104603ed72889236b5a0bcc
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.