Exemplo n.º 1
0
 def setUp(self):
     super(TestCase, self).setUp()
     self._handler = LoggingHandler()
     self._handler.push_application()
     self.addCleanup(self._handler.pop_application)
     gossip.get_group('slash').set_exception_policy(gossip.RaiseImmediately())
     self.override_config("log.console_level", 10000) # silence console in tests
Exemplo n.º 2
0
def test_nested_groups():

    @gossip.register("a.b.c")
    def handler():
        pass

    assert gossip.get_group("a").name == "a"
    assert gossip.get_group("a.b").name == "b"
Exemplo n.º 3
0
def test_get_or_create_group():
    group_name = "group_name"
    with pytest.raises(GroupNotFound):
        gossip.get_group(group_name)

    group = gossip.get_or_create_group(group_name)
    assert isinstance(group, gossip.groups.Group)
    assert group is gossip.get_group(group_name)
Exemplo n.º 4
0
 def setUp(self):
     super(TestCase, self).setUp()
     self._handler = LoggingHandler()
     self._handler.push_application()
     self.addCleanup(self._handler.pop_application)
     gossip.get_group('slash').set_exception_policy(
         gossip.RaiseImmediately())
     self.override_config("log.console_level",
                          10000)  # silence console in tests
Exemplo n.º 5
0
def mute_other_sub_group():
    hook_1 = gossip.define("a.b.c")
    hook_2 = gossip.define("a.c.d")
    hook_3 = gossip.define("a.c.e")

    gossip.get_group("a.b").forbid_muting()
    hook_3.forbid_muting()

    assert not hook_1.can_be_muted()
    assert not hook_3.can_be_muted()
    assert hook_2.can_be_muted()
Exemplo n.º 6
0
def test_mute_group(checkpoint):

    @gossip.register('a.b.c')
    def handler():
        checkpoint()

    gossip.get_group("a").forbid_muting()

    with pytest.raises(CannotMuteHooks):
        with gossip.mute_context(['a.b.c']):
            gossip.trigger('a.b.c')
    assert not checkpoint.called
Exemplo n.º 7
0
def test_builtin_plugins_hooks_start_condition():
    "make sure that all hooks are either empty, or contain callbacks marked with `slash.<identifier>`"
    for hook in gossip.get_group('slash').get_hooks():
        for registration in hook.get_registrations():
            assert registration.token.startswith(
                'slash.'), 'Callback {} is not a builtin!'.format(
                    hook.full_name)
Exemplo n.º 8
0
def test_inherit_policy_changing_parent():
    gossip.define("group.hook")
    group = gossip.get_group("group")
    for policy in (gossip.RaiseImmediately(), gossip.RaiseDefer(),
                   gossip.IgnoreExceptions()):
        gossip.set_exception_policy(policy)
        assert group.get_exception_policy() is policy
Exemplo n.º 9
0
def gossip_raise_immediately():
    g = gossip.get_group('slash')
    prev = g.get_exception_policy()
    g.set_exception_policy(gossip.RaiseImmediately())
    try:
        yield
    finally:
        g.set_exception_policy(prev)
Exemplo n.º 10
0
def gossip_raise_immediately():
    g = gossip.get_group('slash')
    prev = g.get_exception_policy()
    g.set_exception_policy(gossip.RaiseImmediately())
    try:
        yield
    finally:
        g.set_exception_policy(prev)
Exemplo n.º 11
0
 def run(self):
     returned = []
     all_hooks = []
     for hook in sorted(gossip.get_group("slash").get_hooks(), key=lambda hook:hook.name):
         section = nodes.section(ids=[hook.name])
         returned.append(section)
         title = "slash.hooks.{0}".format(hook.name)
         args = hook.get_argument_names()
         if args:
             title += "({0})".format(", ".join(args))
         section.append(nodes.title(text=title))
         section.append(nodes.paragraph(text=hook.doc))
     return returned
Exemplo n.º 12
0
 def run(self):
     returned = []
     all_hooks = []
     for hook in sorted(gossip.get_group("slash").get_hooks(),
                        key=lambda hook: hook.name):
         section = nodes.section(ids=[hook.name])
         returned.append(section)
         title = "slash.hooks.{0}".format(hook.name)
         args = hook.get_argument_names()
         if args:
             title += "({0})".format(", ".join(args))
         section.append(nodes.title(text=title))
         section.append(nodes.paragraph(text=hook.doc))
     return returned
Exemplo n.º 13
0
 def run(self):
     returned = []
     for hook in sorted(gossip.get_group("slash").get_hooks(),
                        key=lambda hook: hook.name):
         section = nodes.section(ids=[hook.name],
                                 names=['hooks.{}'.format(hook.name)])
         self.state.document.note_explicit_target(section)
         returned.append(section)
         title = "slash.hooks.{}".format(hook.name)
         args = hook.get_argument_names()
         if args:
             title += "({})".format(", ".join(args))
         section.append(nodes.title(text=title))
         section.append(nodes.paragraph(text=hook.doc))
     return returned
Exemplo n.º 14
0
def test_group_only_token_unregistration(registrations):  # pylint: disable=unused-argument

    gossip.get_group("group2").unregister_token("token1")
    assert len(_get_all_registrations()) == 3
Exemplo n.º 15
0
 def _cleanup():
     for hook in gossip.get_group("slash").get_hooks():
         hook.unregister_all()
     assert not gossip.get_group("slash").get_subgroups()
Exemplo n.º 16
0
    def _get_plugin_registrations(self, plugin):
        plugin_name = plugin.get_name()
        returned = []
        unknown = []
        global_needs = try_get_mark(plugin, 'plugin_needs', [])
        global_provides = try_get_mark(plugin, 'plugin_provides', [])

        has_session_end = has_session_start = False

        register_no_op_hooks = set()
        if global_provides:
            register_no_op_hooks.update(
                hook.full_name
                for hook in gossip.get_group('slash').get_hooks())

        for method_name in dir(type(plugin)):
            if method_name in _SKIPPED_PLUGIN_METHOD_NAMES:
                continue

            method = getattr(plugin, method_name)

            if not hasattr(method, '__call__'):
                continue

            registration_list = try_get_mark(method, 'register_on', NOTHING)

            if registration_list is not NOTHING:
                registration_list = registration_list[:]
            else:
                if method_name.startswith('_'):
                    continue
                registration_list = [
                    RegistrationInfo("slash.{}".format(method_name),
                                     expect_exists=True)
                ]

            for registration_info in registration_list:
                if registration_info.hook_name is None:
                    # asked not to register for nothing
                    continue

                if not try_get_mark(method, 'register_if', True):
                    continue

                plugin_needs = list(
                    itertools.chain(
                        try_get_mark(method, 'plugin_needs', []), global_needs,
                        registration_info.register_kwargs.get('needs', [])))

                plugin_provides = list(
                    itertools.chain(
                        try_get_mark(method, 'plugin_provides', []),
                        global_provides,
                        registration_info.register_kwargs.get('provides', [])))

                try:
                    if registration_info.expect_exists:
                        hook = gossip.get_hook(registration_info.hook_name)
                    else:
                        hook = gossip.hooks.get_or_create_hook(
                            registration_info.hook_name)
                        if not hook.is_defined() and hook.group.is_strict():
                            raise LookupError()
                except LookupError:
                    unknown.append(registration_info.hook_name)
                    continue

                assert hook is not None
                register_no_op_hooks.discard(registration_info.hook_name)

                kwargs = registration_info.register_kwargs.copy()
                kwargs.update({
                    'needs': plugin_needs,
                    'provides': plugin_provides,
                    'token': self._get_token(plugin_name),
                })
                if registration_info.hook_name == 'slash.session_start':
                    has_session_start = True
                    kwargs['toggles_on'] = plugin.__toggles__['session']
                elif registration_info.hook_name == 'slash.session_end':
                    has_session_end = True
                    kwargs['toggles_off'] = plugin.__toggles__['session']

                returned.append((hook, method, kwargs))

        if has_session_end and not has_session_start:
            hook = gossip.get_hook('slash.session_start')
            returned.append((hook, lambda: None, {
                'toggles_on': plugin.__toggles__['session']
            }))
            register_no_op_hooks.discard(hook.full_name)

        for hook_name in register_no_op_hooks:
            hook = gossip.get_hook(hook_name)
            hook.register_no_op(provides=global_provides,
                                token=self._get_token(plugin_name))

        if unknown:
            raise IncompatiblePlugin("Unknown hooks: {}".format(
                ", ".join(unknown)))
        return returned
Exemplo n.º 17
0
_define('test_success', doc="Called on test success")
_define('test_error', doc="Called on test error")
_define('test_failure', doc="Called on test failure")
_define('test_skip', doc="Called on test skip", arg_names=("reason",))

_define('error_added', doc='Called when an error is added to a result (either test result or global)', arg_names=('error', 'result'))

_define('result_summary', doc="Called at the end of the execution, when printing results")

_define('exception_caught_before_debugger',
        doc="Called whenever an exception is caught, but a debugger hasn't been entered yet")

_define('exception_caught_after_debugger',
        doc="Called whenever an exception is caught, and a debugger has already been run")

_slash_group = gossip.get_group('slash')
_slash_group.set_strict()
_slash_group.set_exception_policy(gossip.RaiseDefer())

@gossip.register('gossip.on_handler_exception') # pylint: disable=unused-argument
def debugger(handler, exception, hook): # pylint: disable=unused-argument
    from .exception_handling import handle_exception

    if hook.group is _slash_group and config.root.debug.debug_hook_handlers:
        handle_exception(exception)

@_deprecated_to_gossip
def add_custom_hook(hook_name):
    """
    Adds an additional hook to the set of available hooks
    """
Exemplo n.º 18
0
 def get_group(self):
     return gossip.get_group(self.hook_name.rsplit('.', 1)[0])
Exemplo n.º 19
0
def test_group_only_token_unregistration(registrations):  # pylint: disable=unused-argument

    gossip.get_group("group2").unregister_token("token1")
    assert len(_get_all_registrations()) == 3
Exemplo n.º 20
0
def get_all_hooks():
    return [
        (hook.name, hook)
        for hook in gossip.get_group('slash').get_hooks()]
Exemplo n.º 21
0
_define('exception_caught_before_debugger',
        doc="Called whenever an exception is caught, but a debugger hasn't been entered yet")
_define('entering_debugger', doc='Called right before entering debugger', arg_names=('exc_info',))

_define('exception_caught_after_debugger',
        doc="Called whenever an exception is caught, and a debugger has already been run")
_define('before_worker_start', doc="Called in parallel execution mode, before the parent starts the child worker",
        arg_names=("worker_config",))

_define('prepare_notification', doc='Called with a message object prior to it being sent via the notifications plugin (if enabled)',
        arg_names=("message",))

_define('before_interactive_shell', doc='Called before starting interactive shell', arg_names=("namespace",))

_slash_group = gossip.get_group('slash')
_slash_group.set_strict()
_slash_group.set_exception_policy(gossip.RaiseDefer())

@gossip.register('gossip.on_handler_exception') # pylint: disable=unused-argument
def debugger(handler, exception, hook): # pylint: disable=unused-argument
    from .exception_handling import handle_exception

    if hook.group is _slash_group and config.root.debug.debug_hook_handlers:
        handle_exception(exception)

@_deprecated_to_gossip
def add_custom_hook(hook_name):
    """
    Adds an additional hook to the set of available hooks
    """
Exemplo n.º 22
0
def get_all_hooks():
    return [
        (hook.name, hook)
        for hook in gossip.get_group('slash').get_hooks()]
Exemplo n.º 23
0
 def _cleanup():
     for hook in gossip.get_group("slash").get_hooks():
         hook.unregister_all()
     assert not gossip.get_group("slash").get_subgroups()
Exemplo n.º 24
0
def test_inherit_policy_changing_parent():
    gossip.define("group.hook")
    group = gossip.get_group("group")
    for policy in (gossip.RaiseImmediately(), gossip.RaiseDefer(), gossip.IgnoreExceptions()):
        gossip.set_exception_policy(policy)
        assert group.get_exception_policy() is policy
Exemplo n.º 25
0
 def get_parent_group(self):
     return gossip.get_group(self.hook_name.split('.')[0])