def test_name_hooks(self):
# register hookables
hook_manager.register_class(MyHookable, MyEvents)
# Install hooks
hook_A: MyHook = MyHook(self, 'Hook-A')
hook_B: MyHook = MyHook(self, 'Hook-B')
hook_C: MyHook = MyHook(self, 'Hook-C')
hook_D: MyHook = MyHook(self, 'Hook-D')
hook_manager.add_hook(MyEvents.CREATE, MyHookable, hook_A.callback)
hook_manager.add_hook(ANY, MyHookable, hook_B.err_callback)
hook_manager.add_hook(MyEvents.CREATE, 'Source-A', hook_C.callback)
hook_manager.add_hook(ANY, 'Source-A', hook_D.err_callback)
# Create event sources, emits CREATE
self.output.clear()
MyHookable(self, 'Source-A', use_name=True)
self.assertListEqual(self.output, [
'Hook Hook-C event CREATE called by Source-A',
'Source-A.CREATE hook call outcome: OK',
'Hook Hook-D event CREATE called by Source-A',
'Source-A.CREATE hook call outcome: ERROR (Error in hook)'
])
def test_any_event(self):
# register hookables
hook_manager.register_class(MyHookable, MyEvents)
# Install hooks
hook_A: MyHook = MyHook(self, 'Hook-A')
hook_B: MyHook = MyHook(self, 'Hook-B')
hook_C: MyHook = MyHook(self, 'Hook-C')
hook_D: MyHook = MyHook(self, 'Hook-D')
hook_manager.add_hook(ANY, MyHookable, hook_A.callback)
hook_manager.add_hook(ANY, MyHookable, hook_B.err_callback)
# Create event sources, emits CREATE
self.output.clear()
src_A: MyHookable = MyHookable(self, 'Source-A', register=True)
self.assertListEqual(self.output, [
'Hook Hook-A event CREATE called by Source-A',
'Source-A.CREATE hook call outcome: OK',
'Hook Hook-B event CREATE called by Source-A',
'Source-A.CREATE hook call outcome: ERROR (Error in hook)'
])
# Install instance hooks
hook_manager.add_hook(ANY, src_A, hook_C.callback)
hook_manager.add_hook(ANY, 'Source-A', hook_D.callback)
# And action!
self.output.clear()
src_A.action()
self.assertListEqual(self.output, [
'Source-A.ACTION!', 'Hook Hook-C event ACTION called by Source-A',
'Source-A.ACTION hook call outcome: OK',
'Hook Hook-D event ACTION called by Source-A',
'Source-A.ACTION hook call outcome: OK',
'Hook Hook-A event ACTION called by Source-A',
'Source-A.ACTION hook call outcome: OK',
'Hook Hook-B event ACTION called by Source-A',
'Source-A.ACTION hook call outcome: ERROR (Error in hook)'
])
# Optimizations
self.assertIn(HookFlag.CLASS, hook_manager.flags)
self.assertIn(HookFlag.INSTANCE, hook_manager.flags)
self.assertIn(HookFlag.ANY_EVENT, hook_manager.flags)
self.assertIn(HookFlag.NAME, hook_manager.flags)
def test_inheritance(self):
# register hookables
hook_manager.register_class(MyHookable, MyEvents)
hook_manager.register_class(MySuperHookable, ('super-action', ))
self.assertTupleEqual(tuple(hook_manager.hookables.keys()),
(MyHookable, MySuperHookable))
self.assertSetEqual(
hook_manager.hookables[MyHookable],
set(x for x in cast(Enum, MyEvents).__members__.values()))
self.assertTupleEqual(hook_manager.hookables[MySuperHookable],
('super-action', ))
# Install hooks
hook_A: MyHook = MyHook(self, 'Hook-A')
hook_B: MyHook = MyHook(self, 'Hook-B')
hook_C: MyHook = MyHook(self, 'Hook-C')
hook_S: MyHook = MyHook(self, 'Hook-S')
#
hook_manager.add_hook(MyEvents.CREATE, MyHookable, hook_A.callback)
hook_manager.add_hook(MyEvents.CREATE, MySuperHookable,
hook_B.err_callback)
hook_manager.add_hook(MyEvents.ACTION, MyHookable, hook_C.callback)
hook_manager.add_hook('super-action', MySuperHookable, hook_S.callback)
#
key = (MyEvents.CREATE, MyHookable, ANY)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_A.callback, hook_manager.hooks[key].callbacks)
key = (MyEvents.CREATE, MySuperHookable, ANY)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_B.err_callback, hook_manager.hooks[key].callbacks)
key = (MyEvents.ACTION, MyHookable, ANY)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_C.callback, hook_manager.hooks[key].callbacks)
# Create event sources, emits CREATE
self.output.clear()
src_A: MySuperHookable = MySuperHookable(self, 'SuperSource-A')
self.assertListEqual(self.output, [
'Hook Hook-A event CREATE called by SuperSource-A',
'SuperSource-A.CREATE hook call outcome: OK',
'Hook Hook-B event CREATE called by SuperSource-A',
'SuperSource-A.CREATE hook call outcome: ERROR (Error in hook)'
])
self.output.clear()
src_B: MySuperHookable = MySuperHookable(self, 'SuperSource-B')
self.assertListEqual(self.output, [
'Hook Hook-A event CREATE called by SuperSource-B',
'SuperSource-B.CREATE hook call outcome: OK',
'Hook Hook-B event CREATE called by SuperSource-B',
'SuperSource-B.CREATE hook call outcome: ERROR (Error in hook)'
])
# Install instance hooks
hook_manager.add_hook(MyEvents.ACTION, src_A, hook_A.callback)
hook_manager.add_hook(MyEvents.ACTION, src_B, hook_B.callback)
#
key = (MyEvents.ACTION, ANY, src_A)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_A.callback, hook_manager.hooks[key].callbacks)
key = (MyEvents.ACTION, ANY, src_B)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_B.callback, hook_manager.hooks[key].callbacks)
# And action!
self.output.clear()
src_A.action()
self.assertListEqual(self.output, [
'SuperSource-A.ACTION!',
'Hook Hook-A event ACTION called by SuperSource-A',
'SuperSource-A.ACTION hook call outcome: OK',
'Hook Hook-C event ACTION called by SuperSource-A',
'SuperSource-A.ACTION hook call outcome: OK'
])
#
self.output.clear()
src_B.action()
self.assertListEqual(self.output, [
'SuperSource-B.ACTION!',
'Hook Hook-B event ACTION called by SuperSource-B',
'SuperSource-B.ACTION hook call outcome: OK',
'Hook Hook-C event ACTION called by SuperSource-B',
'SuperSource-B.ACTION hook call outcome: OK'
])
#
self.output.clear()
src_B.super_action()
self.assertListEqual(self.output, [
'SuperSource-B.SUPER-ACTION!',
'Hook Hook-S event super-action called by SuperSource-B',
'SuperSource-B.SUPER-ACTION hook call outcome: OK'
])
def test_bad_hooks(self):
# register hookables
hook_manager.register_class(MyHookable, MyEvents)
hook_manager.register_class(MySuperHookable, ('super-action', ))
src_A: MyHookable = MyHookable(self, 'Source-A')
src_B: MySuperHookable = MySuperHookable(self, 'SuperSource-B')
# Install hooks
bad_hook: MyHook = MyHook(self, 'BAD-Hook')
# Wrong hookables
with self.assertRaises(TypeError) as cm:
hook_manager.add_hook(MyEvents.CREATE, ANY,
bad_hook.callback) # hook object
self.assertEqual(
cm.exception.args,
("Subject must be hookable class or instance, or name", ))
with self.assertRaises(TypeError) as cm:
hook_manager.add_hook(MyEvents.CREATE, Enum,
bad_hook.callback) # hook class
self.assertEqual(cm.exception.args,
('The type is not registered as hookable', ))
self.assertDictEqual(hook_manager.hooks._reg, {})
# Wrong events
with self.assertRaises(ValueError) as cm:
hook_manager.add_hook('BAD EVENT', MyHookable, bad_hook.callback)
self.assertEqual(
cm.exception.args,
("Event 'BAD EVENT' is not supported by 'MyHookable'", ))
with self.assertRaises(ValueError) as cm:
hook_manager.add_hook('BAD EVENT', MySuperHookable,
bad_hook.callback)
self.assertEqual(
cm.exception.args,
("Event 'BAD EVENT' is not supported by 'MySuperHookable'", ))
#
with self.assertRaises(ValueError) as cm:
hook_manager.add_hook('BAD EVENT', src_A, bad_hook.callback)
self.assertEqual(
cm.exception.args,
("Event 'BAD EVENT' is not supported by 'MyHookable'", ))
with self.assertRaises(ValueError) as cm:
hook_manager.add_hook('BAD EVENT', src_B, bad_hook.callback)
self.assertEqual(
cm.exception.args,
("Event 'BAD EVENT' is not supported by 'MySuperHookable'", ))
# Bad hookable instances
with self.assertRaises(TypeError) as cm:
hook_manager.register_name(self, 'BAD_CLASS')
self.assertEqual(cm.exception.args,
("The instance is not of hookable type", ))
def test_aaa_hooks(self):
# register hookables
hook_manager.register_class(MyHookable, MyEvents)
self.assertTupleEqual(tuple(hook_manager.hookables.keys()),
(MyHookable, ))
self.assertSetEqual(
hook_manager.hookables[MyHookable],
set(x for x in cast(Enum, MyEvents).__members__.values()))
# Optimizations
self.assertNotIn(HookFlag.CLASS, hook_manager.flags)
self.assertNotIn(HookFlag.INSTANCE, hook_manager.flags)
self.assertNotIn(HookFlag.ANY_EVENT, hook_manager.flags)
self.assertNotIn(HookFlag.NAME, hook_manager.flags)
# Install hooks
hook_A: MyHook = MyHook(self, 'Hook-A')
hook_B: MyHook = MyHook(self, 'Hook-B')
hook_C: MyHook = MyHook(self, 'Hook-C')
hook_N: MyHook = MyHook(self, 'Hook-N')
#
hook_manager.add_hook(MyEvents.CREATE, MyHookable, hook_A.callback)
self.assertIn(HookFlag.CLASS, hook_manager.flags)
hook_manager.add_hook(MyEvents.CREATE, MyHookable, hook_B.err_callback)
hook_manager.add_hook(MyEvents.ACTION, MyHookable, hook_C.callback)
hook_manager.add_hook(MyEvents.ACTION, 'Source-A', hook_N.callback)
self.assertIn(HookFlag.NAME, hook_manager.flags)
#
key = (MyEvents.CREATE, MyHookable, ANY)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_A.callback, hook_manager.hooks[key].callbacks)
self.assertIn(hook_B.err_callback, hook_manager.hooks[key].callbacks)
key = (MyEvents.ACTION, MyHookable, ANY)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_C.callback, hook_manager.hooks[key].callbacks)
# Create event sources, emits CREATE
self.output.clear()
src_A: MyHookable = MyHookable(self, 'Source-A', register=True)
self.assertListEqual(self.output, [
'Hook Hook-A event CREATE called by Source-A',
'Source-A.CREATE hook call outcome: OK',
'Hook Hook-B event CREATE called by Source-A',
'Source-A.CREATE hook call outcome: ERROR (Error in hook)'
])
self.output.clear()
src_B: MyHookable = MyHookable(self, 'Source-B', register=True)
self.assertListEqual(self.output, [
'Hook Hook-A event CREATE called by Source-B',
'Source-B.CREATE hook call outcome: OK',
'Hook Hook-B event CREATE called by Source-B',
'Source-B.CREATE hook call outcome: ERROR (Error in hook)'
])
# Install instance hooks
hook_manager.add_hook(MyEvents.ACTION, src_A, hook_A.callback)
self.assertIn(HookFlag.INSTANCE, hook_manager.flags)
hook_manager.add_hook(MyEvents.ACTION, src_B, hook_B.callback)
#
key = (MyEvents.ACTION, ANY, src_A)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_A.callback, hook_manager.hooks[key].callbacks)
key = (MyEvents.ACTION, ANY, src_B)
self.assertTrue(key in hook_manager.hooks)
self.assertIn(hook_B.callback, hook_manager.hooks[key].callbacks)
# And action!
self.output.clear()
src_A.action()
self.assertListEqual(self.output, [
'Source-A.ACTION!', 'Hook Hook-A event ACTION called by Source-A',
'Source-A.ACTION hook call outcome: OK',
'Hook Hook-N event ACTION called by Source-A',
'Source-A.ACTION hook call outcome: OK',
'Hook Hook-C event ACTION called by Source-A',
'Source-A.ACTION hook call outcome: OK'
])
#
self.output.clear()
src_B.action()
self.assertListEqual(self.output, [
'Source-B.ACTION!', 'Hook Hook-B event ACTION called by Source-B',
'Source-B.ACTION hook call outcome: OK',
'Hook Hook-C event ACTION called by Source-B',
'Source-B.ACTION hook call outcome: OK'
])
# Optimizations
self.assertIn(HookFlag.CLASS, hook_manager.flags)
self.assertIn(HookFlag.INSTANCE, hook_manager.flags)
self.assertNotIn(HookFlag.ANY_EVENT, hook_manager.flags)
self.assertIn(HookFlag.NAME, hook_manager.flags)
# Remove hooks
hook_manager.remove_hook(MyEvents.CREATE, MyHookable, hook_A.callback)
key = (MyEvents.CREATE, MyHookable, ANY)
self.assertTrue(key in hook_manager.hooks)
self.assertNotIn(hook_A.callback, hook_manager.hooks[key].callbacks)
hook_manager.remove_hook(MyEvents.CREATE, MyHookable,
hook_B.err_callback)
self.assertFalse(key in hook_manager.hooks)
#
hook_manager.remove_hook(MyEvents.ACTION, src_A, hook_A.callback)
key = (MyEvents.ACTION, ANY, src_A)
self.assertFalse(key in hook_manager.hooks)
#
hook_manager.remove_all_hooks()
self.assertEqual(len(hook_manager.hooks), 0)
#
hook_manager.add_hook(MyEvents.ACTION, MyHookable, hook_C.callback)
hook_manager.reset()
self.assertEqual(len(hook_manager.hookables), 0)
self.assertEqual(len(hook_manager.hooks), 0)