From 41025ba0cb84df6a5fc4a76f090a9d9a79b12e28 Mon Sep 17 00:00:00 2001 From: Graham Dumpleton Date: Tue, 6 Aug 2013 21:33:22 +0800 Subject: [PATCH] Updates to unit tests. --- wrapt/tests/test_function.py | 22 +++++++++ wrapt/tests/test_inner_classmethod.py | 4 ++ wrapt/tests/test_inner_staticmethod.py | 62 ++++++++++++++++++++++++ wrapt/tests/test_instancemethod.py | 37 +++++++++++--- wrapt/tests/test_nested_function.py | 28 +++++++++++ wrapt/tests/test_outer_classmethod.py | 4 ++ wrapt/tests/test_outer_staticmethod.py | 67 ++++++++++++++++++++++++++ 7 files changed, 216 insertions(+), 8 deletions(-) diff --git a/wrapt/tests/test_function.py b/wrapt/tests/test_function.py index da58636..25d018d 100644 --- a/wrapt/tests/test_function.py +++ b/wrapt/tests/test_function.py @@ -67,6 +67,28 @@ class TestCallingFunction(unittest.TestCase): @wrapt.function_decorator def _decorator(wrapped, args, kwargs): + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) + return wrapped(*args, **kwargs) + + @_decorator + def _function(*args, **kwargs): + return args, kwargs + + result = _function(*_args, **_kwargs) + + self.assertEqual(result, (_args, _kwargs)) + + def test_call_function_generic_decorator(self): + _args = (1, 2) + _kwargs = { 'one': 1, 'two': 2 } + + @wrapt.generic_decorator + def _decorator(wrapped, obj, cls, args, kwargs): + self.assertEqual(obj, None) + self.assertEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator diff --git a/wrapt/tests/test_inner_classmethod.py b/wrapt/tests/test_inner_classmethod.py index 29743ae..798a456 100644 --- a/wrapt/tests/test_inner_classmethod.py +++ b/wrapt/tests/test_inner_classmethod.py @@ -118,6 +118,8 @@ class TestCallingInnerClassMethod(unittest.TestCase): def _decorator(wrapped, obj, cls, args, kwargs): self.assertEqual(obj, None) self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -146,6 +148,8 @@ class TestCallingInnerClassMethod(unittest.TestCase): def _decorator(wrapped, obj, cls, args, kwargs): self.assertNotEqual(obj, None) self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator diff --git a/wrapt/tests/test_inner_staticmethod.py b/wrapt/tests/test_inner_staticmethod.py index 0407dca..509cdf5 100644 --- a/wrapt/tests/test_inner_staticmethod.py +++ b/wrapt/tests/test_inner_staticmethod.py @@ -1,5 +1,7 @@ from __future__ import print_function +import wrapt + import unittest import inspect @@ -103,3 +105,63 @@ class TestNamingInnerStaticMethod(unittest.TestCase): self.assertTrue(isinstance(Class().function, type(Original().function))) + +class TestCallingInnerStaticMethod(unittest.TestCase): + + def test_class_call_function(self): + # Test calling staticmethod. + + _args = (1, 2) + _kwargs = { 'one': 1, 'two': 2 } + + @wrapt.generic_decorator + def _decorator(wrapped, obj, cls, args, kwargs): + self.assertEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) + return wrapped(*args, **kwargs) + + @_decorator + def _function(*args, **kwargs): + return args, kwargs + + class Class(object): + @_decorator + @staticmethod + def _function(*args, **kwargs): + return (args, kwargs) + + result = Class._function(*_args, **_kwargs) + + self.assertEqual(result, (_args, _kwargs)) + + def test_instance_call_function(self): + # Test calling staticmethod via class instance. The instance + # passed to the wrapper will not be None because our decorator + # surrounds the staticmethod decorator. + + _args = (1, 2) + _kwargs = { 'one': 1, 'two': 2 } + + @wrapt.generic_decorator + def _decorator(wrapped, obj, cls, args, kwargs): + self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) + return wrapped(*args, **kwargs) + + @_decorator + def _function(*args, **kwargs): + return args, kwargs + + class Class(object): + @_decorator + @staticmethod + def _function(*args, **kwargs): + return (args, kwargs) + + result = Class()._function(*_args, **_kwargs) + + self.assertEqual(result, (_args, _kwargs)) diff --git a/wrapt/tests/test_instancemethod.py b/wrapt/tests/test_instancemethod.py index c4c44a4..107ffcb 100644 --- a/wrapt/tests/test_instancemethod.py +++ b/wrapt/tests/test_instancemethod.py @@ -217,6 +217,9 @@ class TestCallingInstanceMethodOldStyle(unittest.TestCase): @wrapt.instancemethod_decorator def _decorator(wrapped, obj, cls, args, kwargs): self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -241,6 +244,9 @@ class TestCallingInstanceMethodOldStyle(unittest.TestCase): @wrapt.instancemethod_decorator def _decorator(wrapped, obj, cls, args, kwargs): self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -258,17 +264,17 @@ class TestCallingInstanceMethodOldStyle(unittest.TestCase): def test_class_call_function_generic_decorator(self): # Test calling instancemethod via class and passing in the class - # instance directly. The generic decorator does not perform the - # fiddle that the instance method decorator does when called via - # the class type with the instance as first argument. Thus the - # instance passed to the wrapper will be None. + # instance directly. _args = (1, 2) _kwargs = { 'one': 1, 'two': 2 } @wrapt.generic_decorator def _decorator(wrapped, obj, cls, args, kwargs): - self.assertEqual(obj, None) + self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -293,6 +299,9 @@ class TestCallingInstanceMethodOldStyle(unittest.TestCase): @wrapt.generic_decorator def _decorator(wrapped, obj, cls, args, kwargs): self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -312,7 +321,7 @@ class TestCallingInstanceMethodNewStyle(unittest.TestCase): def test_class_call_function(self): # Test calling instancemethod via class and passing in the class - # instance directly. This is bypassing the descriptor protocol. + # instance directly. _args = (1, 2) _kwargs = { 'one': 1, 'two': 2 } @@ -320,6 +329,9 @@ class TestCallingInstanceMethodNewStyle(unittest.TestCase): @wrapt.instancemethod_decorator def _decorator(wrapped, obj, cls, args, kwargs): self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -344,6 +356,9 @@ class TestCallingInstanceMethodNewStyle(unittest.TestCase): @wrapt.instancemethod_decorator def _decorator(wrapped, obj, cls, args, kwargs): self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -361,14 +376,17 @@ class TestCallingInstanceMethodNewStyle(unittest.TestCase): def test_class_call_function_generic_decorator(self): # Test calling instancemethod via class and passing in the class - # instance directly. This is bypassing the descriptor protocol. + # instance directly. _args = (1, 2) _kwargs = { 'one': 1, 'two': 2 } @wrapt.generic_decorator def _decorator(wrapped, obj, cls, args, kwargs): - self.assertEqual(obj, None) + self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -393,6 +411,9 @@ class TestCallingInstanceMethodNewStyle(unittest.TestCase): @wrapt.generic_decorator def _decorator(wrapped, obj, cls, args, kwargs): self.assertNotEqual(obj, None) + self.assertNotEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator diff --git a/wrapt/tests/test_nested_function.py b/wrapt/tests/test_nested_function.py index 8f4b622..d716709 100644 --- a/wrapt/tests/test_nested_function.py +++ b/wrapt/tests/test_nested_function.py @@ -71,6 +71,34 @@ class TestCallingNestedFunction(unittest.TestCase): @wrapt.function_decorator def _decorator(wrapped, args, kwargs): + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) + return wrapped(*args, **kwargs) + + @_decorator + def _function(*args, **kwargs): + return args, kwargs + + def _function(): + @passthru_function_decorator + def inner(*args, **kwargs): + return args, kwargs + return inner + + result = _function()(*_args, **_kwargs) + + self.assertEqual(result, (_args, _kwargs)) + + def test_call_function_generic_decorator(self): + _args = (1, 2) + _kwargs = { 'one': 1, 'two': 2 } + + @wrapt.generic_decorator + def _decorator(wrapped, obj, cls, args, kwargs): + self.assertEqual(obj, None) + self.assertEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator diff --git a/wrapt/tests/test_outer_classmethod.py b/wrapt/tests/test_outer_classmethod.py index 3a99d29..0013149 100644 --- a/wrapt/tests/test_outer_classmethod.py +++ b/wrapt/tests/test_outer_classmethod.py @@ -123,6 +123,8 @@ class TestCallingOuterClassMethod(unittest.TestCase): def _decorator(wrapped, obj, cls, args, kwargs): self.assertEqual(obj, None) self.assertEqual(cls, None) + self.assertEqual(args, (Class,)+_args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator @@ -154,6 +156,8 @@ class TestCallingOuterClassMethod(unittest.TestCase): def _decorator(wrapped, obj, cls, args, kwargs): self.assertEqual(obj, None) self.assertEqual(cls, None) + self.assertEqual(args, (Class,)+_args) + self.assertEqual(kwargs, _kwargs) return wrapped(*args, **kwargs) @_decorator diff --git a/wrapt/tests/test_outer_staticmethod.py b/wrapt/tests/test_outer_staticmethod.py index 118b5b0..50d761a 100644 --- a/wrapt/tests/test_outer_staticmethod.py +++ b/wrapt/tests/test_outer_staticmethod.py @@ -3,6 +3,8 @@ from __future__ import print_function import unittest import inspect +import wrapt + from .decorators import passthru_generic_decorator class Class(object): @@ -103,3 +105,68 @@ class TestNamingOuterStaticMethod(unittest.TestCase): self.assertTrue(isinstance(Class().function, type(Original().function))) + +class TestCallingOuterStaticMethod(unittest.TestCase): + + def test_class_call_function(self): + # Test calling staticmethod. The instance and class passed to the + # wrapper will both be None because our decorator is surrounded + # by the staticmethod decorator. The staticmethod decorator + # doesn't bind the method and treats it like a normal function. + + _args = (1, 2) + _kwargs = { 'one': 1, 'two': 2 } + + @wrapt.generic_decorator + def _decorator(wrapped, obj, cls, args, kwargs): + self.assertEqual(obj, None) + self.assertEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) + return wrapped(*args, **kwargs) + + @_decorator + def _function(*args, **kwargs): + return args, kwargs + + class Class(object): + @staticmethod + @_decorator + def _function(*args, **kwargs): + return (args, kwargs) + + result = Class._function(*_args, **_kwargs) + + self.assertEqual(result, (_args, _kwargs)) + + def test_instance_call_function(self): + # Test calling staticmethod via class instance. The instance + # and class passed to the wrapper will both be None because our + # decorator is surrounded by the staticmethod decorator. The + # staticmethod decorator doesn't bind the method and treats it + # like a normal function. + + _args = (1, 2) + _kwargs = { 'one': 1, 'two': 2 } + + @wrapt.generic_decorator + def _decorator(wrapped, obj, cls, args, kwargs): + self.assertEqual(obj, None) + self.assertEqual(cls, None) + self.assertEqual(args, _args) + self.assertEqual(kwargs, _kwargs) + return wrapped(*args, **kwargs) + + @_decorator + def _function(*args, **kwargs): + return args, kwargs + + class Class(object): + @staticmethod + @_decorator + def _function(*args, **kwargs): + return (args, kwargs) + + result = Class()._function(*_args, **_kwargs) + + self.assertEqual(result, (_args, _kwargs))