async def test_wrap_listeners_context(self) -> None: mock = Mock() with emitter.context() as ctx: listeners = ctx.wrap_listeners(Global) emitter.on("test", listeners, mock) self.assertTrue(await emitter.emit(None, Global, scope="test")) mock.assert_called_once_with(None) mock.reset_mock() self.assertTrue(await emitter.emit(None, listeners, scope="test")) mock.assert_called_once_with(None) mock.reset_mock() self.assertTrue(emitter.remove("test", Global, mock, ctx)) self.assertFalse(await emitter.emit(None, Global, scope="test")) self.assertFalse(await emitter.emit(None, listeners, scope="test")) mock.assert_not_called() emitter.on("test", listeners, mock) self.assertTrue(await emitter.emit(None, Global, scope="test")) mock.assert_called_once_with(None) mock.reset_mock() self.assertTrue(await emitter.emit(None, listeners, scope="test")) mock.assert_called_once_with(None) mock.reset_mock() self.assertTrue(emitter.remove("test", listeners, mock)) self.assertFalse(await emitter.emit(None, Global, scope="test")) self.assertFalse(await emitter.emit(None, listeners, scope="test")) mock.assert_not_called()
async def async_main_listener1(_: T.Any) -> None: await asyncio.sleep(0) emitter.on(object, Global, lambda x: mock(5), scope="test") emitter.remove(None, Global, async_main_listener1, scope="test")
async def test_once_fail_context(self) -> None: mock = Mock() with self.assertRaisesRegex( ValueError, "Can't use context manager with a once listener"): emitter.on(Event, Global, mock, once=True, context=True) self.assertFalse(await emitter.emit(Event("0"), Global)) mock.assert_not_called()
async def test_listener_simple(self) -> None: listener = Mock() emitter.on(Event, Global, listener) e = Event("Wowow") self.assertTrue(await emitter.emit(e, Global)) listener.assert_called_once_with(e)
async def test_invalid_types_object(self) -> None: mock = Mock() with self.assertRaises(ValueError): emitter.on(object, Global, mock) with self.assertRaises(ValueError): await emitter.emit(object(), Global) mock.assert_not_called()
async def test_invalid_types_base_exp(self) -> None: mock = Mock() with self.assertRaises(ValueError): emitter.on(BaseException, Global, mock) with self.assertRaises(BaseException): await emitter.emit(BaseException(), Global) mock.assert_not_called()
async def test_superclass_listeners(self) -> None: class Event2(Event): pass mock = Mock() emitter.on(Event, Global, mock) e = Event2("") await emitter.emit(e, Global) mock.assert_called_once_with(e)
async def test_invalid_types_base_exp_subclass(self) -> None: mock = Mock() class Exp(BaseException): pass with self.assertRaises(ValueError): emitter.on(Exp, Global, mock) with self.assertRaises(Exp): await emitter.emit(Exp(), Global) mock.assert_not_called()
async def test_slotted_class_with_loop(self) -> None: mock = Mock() event = Event("") class Listener: __slots__ = tuple() def __call__(self, e: Event) -> None: mock(e) emitter.on(Event, Global, Listener(), loop=self.loop) self.assertTrue(await emitter.emit(event, Global)) mock.assert_called_once_with(event)
async def test_invalid_types_metaclass(self) -> None: mock = Mock() class Meta(type): pass with self.assertRaises(ValueError): emitter.on(Meta, Global, mock) with self.assertRaises(ValueError): await emitter.emit(Meta("", tuple(), {}), Global) mock.assert_not_called()
async def test_emit_none(self) -> None: mock = Mock() emitter.on("test", Global, mock) with self.assertRaisesRegex( ValueError, "Event type can only be None when accompanied of a scope"): await emitter.emit(None, Global) mock.assert_not_called() self.assertTrue(await emitter.emit(None, Global, scope="test")) mock.assert_called_once_with(None)
async def test_listener_callable_class(self) -> None: mock = Mock() this = self class Listener: def __call__(self, event: Event) -> None: this.assertEqual("Wowow", event.data) mock(event) emitter.on(Event, Global, Listener()) e = Event("Wowow") self.assertTrue(await emitter.emit(e, Global)) mock.assert_called_once_with(e)
async def test_once_emit_after_remove(self) -> None: mock = Mock() emitter.on(Event, Global, mock, once=True) emitter.remove(None, Global) e = Event("0") results = await asyncio.gather( emitter.emit(e, Global), emitter.emit(e, Global), emitter.emit(e, Global), emitter.emit(e, Global), emitter.emit(e, Global), ) self.assertListEqual([False, False, False, False, False], results) mock.assert_not_called()
async def test_once(self) -> None: mock = Mock() emitter.on(Event, Global, mock, once=True) e = Event("0") self.assertTrue(await emitter.emit(e, Global)) mock.assert_called_once_with(e) mock.reset_mock() self.assertFalse(await emitter.emit(Event("1"), Global)) mock.assert_not_called() self.assertFalse(await emitter.emit(Event("2"), Global)) mock.assert_not_called() self.assertFalse(await emitter.emit(Event("3"), Global)) mock.assert_not_called()
async def test_once_emit_before_remove(self) -> None: e = Event("0") mock = Mock() emitter.on(Event, Global, mock, once=True) emit_task = asyncio.gather( emitter.emit(e, Global), emitter.emit(e, Global), emitter.emit(e, Global), emitter.emit(e, Global), emitter.emit(e, Global), ) emitter.remove(None, Global) results = await emit_task self.assertIn(True, results) results.remove(True) self.assertListEqual([False, False, False, False], results) mock.assert_called_once_with(e)
def test_invalid_types_not_callable(self) -> None: with self.assertRaisesRegex(ValueError, "Listener must be callable"): emitter.on(str, Global, "") with self.assertRaisesRegex(ValueError, "Listener must be callable"): emitter.on(str, Global, 1) with self.assertRaisesRegex(ValueError, "Listener must be callable"): emitter.on(str, Global, []) with self.assertRaisesRegex(ValueError, "Listener must be callable"): emitter.on(str, Global, {})
async def test_listener_handle_raise_error(self) -> None: exc = RuntimeError("Ooops...") mock = Mock() mock1 = Mock() self.loop.set_exception_handler(mock1) @emitter.on(Event, Global, raise_on_exc=True) async def listener(_: T.Any) -> None: await asyncio.sleep(0) raise exc emitter.on(RuntimeError, listener, mock) await emitter.emit(Event("Wowow"), Global) # Allow the loop to cycle once await asyncio.sleep(0) mock1.assert_not_called() mock.assert_called_once_with(exc)
async def test_listener_context(self) -> None: listener = Mock() ctx = emitter.on(Event, Global, listener, context=True) self.assertIsInstance(ctx, T.ContextManager) with ctx: e = Event("Wowow") self.assertTrue(await emitter.emit(e, Global)) listener.assert_called_once_with(e) self.assertFalse(emitter.remove(Event, Global, listener))
async def test_listener_coro_handle_error(self) -> None: exc = RuntimeError("Ooops...") mock = Mock() future_error = self.loop.create_future() @self.loop.set_exception_handler def handle_error(_, ctx) -> None: future_error.set_exception(ctx["exception"]) @emitter.on(Event, Global) async def listener(_: T.Any) -> None: await asyncio.sleep(0) raise exc emitter.on(RuntimeError, listener, mock) await emitter.emit(Event("Wowow"), Global) # Allow the loop to cycle once await asyncio.sleep(0) self.assertFalse(future_error.done()) mock.assert_called_once_with(exc)
async def test_listener_cancellation(self) -> None: mock = Mock() future_error = self.loop.create_future() @self.loop.set_exception_handler def handle_error(_, ctx) -> None: future_error.set_exception(ctx["exception"]) @emitter.on(Event, Global) def listener(_: T.Any) -> None: fut = self.loop.create_future() fut.cancel() return fut emitter.on(Event, Global, mock) e = Event("Wowow") await emitter.emit(e, Global) with self.assertRaises(CancelledError): await future_error mock.assert_called_once_with(e)
async def test_context_stack(self) -> None: mock = Mock() with emitter.context() as ctx0: emitter.on("test", Global, lambda x: mock(1)) @emitter.on("test", Global) async def async_main_listener0(_: T.Any) -> None: await asyncio.sleep(0) emitter.on("test", Global, lambda x: mock(2)) emitter.remove("test", Global, async_main_listener0) with emitter.context() as ctx1: emitter.on("test", Global, lambda x: mock(3)) with emitter.context() as ctx2: emitter.on("test", Global, lambda x: mock(4)) with emitter.context(): @emitter.on("test", Global) async def async_main_listener1(_: T.Any) -> None: await asyncio.sleep(0) emitter.on("test", Global, lambda x: mock(5)) emitter.remove("test", Global, async_main_listener1) with emitter.context(): emitter.on("test", Global, lambda x: mock(6)) with emitter.context() as ctx3: listener0 = ctx3.wrap_listeners(Global) with emitter.context(): emitter.on("test", listener0, lambda x: mock(7)) with emitter.context() as ctx5: listener1 = ctx5.wrap_listeners(Global) @emitter.on("test", Global) async def setup_remove(_: T.Any) -> None: await asyncio.sleep(0) emitter.remove("test", Global) emitter.on("test", listener1, lambda x: mock(8)) self.assertTrue(await emitter.emit(None, Global, scope="test")) mock.assert_has_calls( [call(1), call(3), call(4), call(6), call(7), call(8)]) mock.reset_mock() self.assertTrue(await emitter.emit(None, Global, scope="test")) mock.assert_has_calls( [call(1), call(3), call(4), call(6), call(2), call(5)]) mock.reset_mock() emitter.remove(None, Global, context=ctx2) self.assertTrue(await emitter.emit(None, Global, scope="test")) mock.assert_has_calls([call(1), call(3), call(6), call(2), call(5)]) mock.reset_mock() emitter.remove(None, Global, context=ctx0) self.assertTrue(await emitter.emit(None, Global, scope="test")) mock.assert_has_calls([call(3), call(6), call(5)]) mock.reset_mock() emitter.remove(None, Global, context=ctx1) self.assertFalse(await emitter.emit(None, Global, scope="test")) mock.assert_not_called()
async def async_main_listener1(_: T.Any) -> None: await asyncio.sleep(0) emitter.on("test", Global, lambda x: mock(5)) emitter.remove("test", Global, async_main_listener1)
def main_listener(_: T.Any) -> None: emitter.on(object, Global, mock, scope=scope)
def main_listener(_: T.Any) -> None: emitter.on("test", Global, mock)
def main_listener(_: T.Any) -> None: emitter.on(scope, Global, mock)
import emitter import tkinter import json # key valid for 24 hours key = "m6IK_VC94AAIqOVZZRe-x8NSED2PMfeg" channel = "camarao-iot" emitter = emitter.Emitter() options = {"secure": True} emitter.connect(options) emitter.on("connect", lambda: print("Connected\n\n")) emitter.on("disconnect", lambda: print("Disconnected\n\n")) emitter.on("presence", lambda p: print("Presence message : '" + str(p) + "'\n\n")) emitter.on("message", lambda m: print("Message received: " + m.asString() + "\n\n")) emitter.loopStart() emitter.publish(key, channel, json.dumps({"test": "test 123"})) import time, sys while True: try: time.sleep(.3) except KeyboardInterrupt: print("Shutting down...") emitter.unsubscribe(key, channel) emitter.loopStop() emitter.disconnect() sys.exit()
async def async_main_listener(_: T.Any) -> None: await asyncio.sleep(0) emitter.on(object, Global, mock2, scope="test")
async def async_main_listener(_: T.Any) -> None: await asyncio.sleep(0) emitter.on(scope, Global, mock2)
async def test_listener_scope(self) -> None: mock = Mock() new_listener = Mock() emitter.on(emitter.NewListener, Global, lambda nl: new_listener(nl.type), scope="scope.test") emitter.on(Event, Global, lambda _: mock(0)) emitter.on(object, Global, lambda _: mock(1), scope="scope") emitter.on(Exception, Global, lambda _: mock(2), scope="scope") emitter.on(object, Global, lambda _: mock(3), scope="scope.test") emitter.on(object, Global, lambda _: mock(4), scope="scope...test.") emitter.on(RuntimeError, Global, lambda _: mock(5), scope="scope.test.") emitter.on(object, Global, lambda _: mock(6), scope="scope.test.deep") emitter.on(object, Global, lambda _: mock(7), scope="scope.test.deep.owo") emitter.on(ValueError, Global, lambda _: mock(8), scope="scope..test....deep..owo.") emitter.on(object, Global, lambda _: mock(9), scope="scope..test....deep..owo.") new_listener.assert_has_calls([ call(object), call(object), call(RuntimeError), call(object), call(object), call(ValueError), call(object), ]) new_listener.reset_mock() e = Event("Wowow") self.assertTrue(await emitter.emit(e, Global)) mock.assert_called_once_with(0) mock.reset_mock() self.assertTrue(await emitter.emit(e, Global, scope=("scope", "test", "deep", "owo"))) mock.assert_has_calls( [call(7), call(9), call(6), call(3), call(4), call(1), call(0)]) mock.reset_mock() self.assertTrue(await emitter.emit(e, Global, scope="..scope.test...")) mock.assert_has_calls([call(3), call(4), call(1), call(0)]) mock.reset_mock() with self.assertRaises(ValueError): await emitter.emit(ValueError(), Global) self.assertTrue(await emitter.emit(ValueError(), Global, scope="scope")) mock.assert_has_calls([call(2)]) mock.reset_mock() self.assertTrue(await emitter.emit(RuntimeError(), Global, scope=("scope", "test", "deep", "owo"))) mock.assert_has_calls([ call(7), call(9), call(6), call(5), call(3), call(4), call(2), call(1) ]) mock.reset_mock() self.assertTrue(await emitter.emit(ValueError(), Global, scope=".scope.test.deep.owo")) mock.assert_has_calls([ call(8), call(7), call(9), call(6), call(3), call(4), call(2), call(1) ]) mock.reset_mock() new_listener.assert_not_called()