def test_monkeypatch_classmethod_subclass():
    '''
    Test `monkeypatch` on a subclass of `classmethod`.
    
    This is useful in Django, that uses its own `classmethod` subclass.
    '''
    class FunkyClassMethod(classmethod):
        is_funky = True

    class A(EqualByIdentity):
        @FunkyClassMethod
        def my_funky_class_method(cls):
            raise 'Flow should never reach here.'
        
    @monkeypatching_tools.monkeypatch(A)
    @FunkyClassMethod
    def my_funky_class_method(cls):
        return cls

    assert isinstance(cute_inspect.getattr_static(A, 'my_funky_class_method'),
                      FunkyClassMethod)
    assert cute_inspect.getattr_static(A, 'my_funky_class_method').is_funky
    assert isinstance(A.my_funky_class_method, types.MethodType)
    
    assert A.my_funky_class_method() == A
    
    a0 = A()
    assert a0.my_funky_class_method() == A
def test_monkeypatch_classmethod_subclass():
    """
    Test `monkeypatch` on a subclass of `classmethod`.
    
    This is useful in Django, that uses its own `classmethod` subclass.
    """
    if sys.version_info[:2] == (2, 6):
        raise nose.SkipTest

    class FunkyClassMethod(classmethod):
        is_funky = True

    class A(EqualByIdentity):
        @FunkyClassMethod
        def my_funky_class_method(cls):
            raise "Flow should never reach here."

    @monkeypatching_tools.monkeypatch(A)
    @FunkyClassMethod
    def my_funky_class_method(cls):
        return cls

    assert isinstance(cute_inspect.getattr_static(A, "my_funky_class_method"), FunkyClassMethod)
    assert cute_inspect.getattr_static(A, "my_funky_class_method").is_funky
    assert isinstance(A.my_funky_class_method, types.MethodType)

    assert A.my_funky_class_method() == A

    a0 = A()
    assert a0.my_funky_class_method() == A
def test_monkeypatch_classmethod():
    class A(EqualByIdentity):
        @classmethod
        def my_class_method(cls):
            raise "Flow should never reach here."

    @monkeypatching_tools.monkeypatch(A)
    @classmethod
    def my_class_method(cls):
        return cls

    assert isinstance(cute_inspect.getattr_static(A, "my_class_method"), classmethod)
    assert isinstance(A.my_class_method, types.MethodType)

    assert A.my_class_method() == A

    a0 = A()
    assert a0.my_class_method() == A
def test_monkeypatch_staticmethod():
    class A(EqualByIdentity):
        @staticmethod
        def my_static_method(x):
            raise "Flow should never reach here."

    @monkeypatching_tools.monkeypatch(A)
    @staticmethod
    def my_static_method(x):
        return (x, "Success")

    assert isinstance(cute_inspect.getattr_static(A, "my_static_method"), staticmethod)
    assert isinstance(A.my_static_method, types.FunctionType)

    assert A.my_static_method(3) == A.my_static_method(3) == (3, "Success")

    a0 = A()
    assert a0.my_static_method(3) == a0.my_static_method(3) == (3, "Success")
def test_monkeypatch_classmethod():
    class A(EqualByIdentity):
        @classmethod
        def my_class_method(cls):
            raise 'Flow should never reach here.'

    @monkeypatching_tools.monkeypatch(A)
    @classmethod
    def my_class_method(cls):
        return cls

    assert isinstance(cute_inspect.getattr_static(A, 'my_class_method'),
                      classmethod)
    assert isinstance(A.my_class_method, types.MethodType)

    assert A.my_class_method() == A

    a0 = A()
    assert a0.my_class_method() == A
def test_monkeypatch_staticmethod():
    class A(EqualByIdentity):
        @staticmethod
        def my_static_method(x):
            raise 'Flow should never reach here.'

    @monkeypatching_tools.monkeypatch(A)
    @staticmethod
    def my_static_method(x):
        return (x, 'Success')

    assert isinstance(cute_inspect.getattr_static(A, 'my_static_method'),
                      staticmethod)
    assert isinstance(A.my_static_method, types.FunctionType)

    assert A.my_static_method(3) == A.my_static_method(3) == (3, 'Success')

    a0 = A()
    assert a0.my_static_method(3) == a0.my_static_method(3) == (3, 'Success')
def test_monkeypatch_classmethod():

    class A(object):
        @classmethod
        def my_class_method(cls):
            raise 'Flow should never reach here.'
        
    @monkeypatching_tools.monkeypatch_method(A)
    @classmethod
    def my_class_method(cls):
        return cls

    assert isinstance(cute_inspect.getattr_static(A, 'my_class_method'),
                      classmethod)
    assert isinstance(A.my_class_method, types.MethodType)
    
    assert A.my_class_method() == A
    
    a0 = A()
    assert a0.my_class_method() == A
def test_monkeypatch_staticmethod():

    class A(object):
        @staticmethod
        def my_static_method(x):
            raise 'Flow should never reach here.'
        
    @monkeypatching_tools.monkeypatch_method(A)
    @staticmethod
    def my_static_method(x):
        return 'Success'
    
    assert isinstance(cute_inspect.getattr_static(A, 'my_static_method'),
                      staticmethod)
    assert isinstance(A.my_static_method, types.FunctionType)
    
    assert A.my_static_method(3) == A.my_static_method('Whatever') == \
                                                                      'Success'
    
    a0 = A()
    assert a0.my_static_method(3) == a0.my_static_method('Whatever') == \
                                                                      'Success'