Strange behaviour when redefining hook and assigning it to a different stage

The following code leads to the strange behaviour that the second check_x() overrides the first (as expected) but the hooks are not overridden, leaving the second check_x() executing as a post-init hook. We should either disable redefinitions of the same hook in the same class or have the second definition and hook override completely the first one.

@simple_test
class my_test(RegressionTest):
    x = variable(int, value=10)

    @run_after('init')
    def check_x(self):
        '''Test will not be listed or run if filtered here'''
        self.skip_if(self.x < 3, 'x is lower than 3')

    @run_after('setup')
    def check_x(self):
        '''Test will be skipped during runtime'''
        self.skip_if(self.x < 5, 'x is lower than 5')

[teojgo]

What actually happens is the following:

1. check_x is first added to the hook registry as a post_init hook https://github.com/eth-cscs/reframe/blob/12b48588980e411fbfe17f32b864fd6eaf7450b5/reframe/core/hooks.py#L154
2. check_x is added to the hook registry as a post_setup hook, but because it’s wrapped as a Hook instance and has the same name as the check_x on step 1, it’s not taken into account, since a hook with the same name is already in the registry
3. Finally when the hooks are assigned to each stage of the pipeline via https://github.com/eth-cscs/reframe/blob/12b48588980e411fbfe17f32b864fd6eaf7450b5/reframe/core/hooks.py#L82, the hook that resides in the registry is the post_init one with the check_x name, but the RegressionTest object attribute named check_x refers to the second check_x function that replaced the first.
4. Therefore, you have the second check_x executed as a post_init hook

I suggest overriding completely a hook with the same name if redefined as another stage hook.

[vkarak]

Nice find and intricate bug! Thanks @teojgo for investigating!

I suggest overriding completely a hook with the same name if redefined as another stage hook.

Yes, I think it makes sense and it is compatible with what happens when a hook is redefined in a subclass.