From ff4a092dab7b1f452b73e7bc25c42a13ce180243 Mon Sep 17 00:00:00 2001 From: Roman Mogilatov Date: Thu, 12 Mar 2015 12:01:56 +0200 Subject: [PATCH] adding utils tests, fixing of bug in utils with returning True for checked classes, not only instances --- objects/utils.py | 17 ++++-- tests/test_utils.py | 139 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 151 insertions(+), 5 deletions(-) create mode 100644 tests/test_utils.py diff --git a/objects/utils.py b/objects/utils.py index c8a3f877..dfc9add0 100644 --- a/objects/utils.py +++ b/objects/utils.py @@ -1,26 +1,33 @@ """Utils module.""" +from inspect import isclass + def is_provider(instance): """Check if instance is provider instance.""" - return hasattr(instance, '__IS_OBJECTS_PROVIDER__') + return (not isclass(instance) and + hasattr(instance, '__IS_OBJECTS_PROVIDER__')) def is_injection(instance): """Check if instance is injection instance.""" - return hasattr(instance, '__IS_OBJECTS_INJECTION__') + return (not isclass(instance) and + hasattr(instance, '__IS_OBJECTS_INJECTION__')) def is_init_arg_injection(instance): """Check if instance is init arg injection instance.""" - return hasattr(instance, '__IS_OBJECTS_INIT_ARG_INJECTION__') + return (not isclass(instance) and + hasattr(instance, '__IS_OBJECTS_INIT_ARG_INJECTION__')) def is_attribute_injection(instance): """Check if instance is attribute injection instance.""" - return hasattr(instance, '__IS_OBJECTS_ATTRIBUTE_INJECTION__') + return (not isclass(instance) and + hasattr(instance, '__IS_OBJECTS_ATTRIBUTE_INJECTION__')) def is_method_injection(instance): """Check if instance is method injection instance.""" - return hasattr(instance, '__IS_OBJECTS_METHOD_INJECTION__') + return (not isclass(instance) and + hasattr(instance, '__IS_OBJECTS_METHOD_INJECTION__')) diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 00000000..d6a44b18 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,139 @@ +"""Objects utils unittests.""" + +import unittest2 as unittest + +from objects.utils import is_provider +from objects.utils import is_injection +from objects.utils import is_init_arg_injection +from objects.utils import is_attribute_injection +from objects.utils import is_method_injection + +from objects.providers import Provider + +from objects.injections import Injection +from objects.injections import InitArg +from objects.injections import Attribute +from objects.injections import Method + + +class IsProviderTest(unittest.TestCase): + + """`is_provider()` test cases.""" + + def test_with_instance(self): + """Test with instance.""" + self.assertTrue(is_provider(Provider())) + + def test_with_class(self): + """Test with class.""" + self.assertFalse(is_provider(Provider)) + + def test_with_string(self): + """Test with string.""" + self.assertFalse(is_provider('some_string')) + + def test_with_object(self): + """Test with object.""" + self.assertFalse(is_provider(object())) + + +class IsInjectionTest(unittest.TestCase): + + """`is_injection()` test cases.""" + + def test_with_instance(self): + """Test with instance.""" + self.assertTrue(is_injection(Injection('name', 'value'))) + + def test_with_subclass_instances(self): + """Test with subclass instances.""" + self.assertTrue(is_injection(InitArg('name', 'value'))) + self.assertTrue(is_injection(Attribute('name', 'value'))) + self.assertTrue(is_injection(Method('name', 'value'))) + + def test_with_class(self): + """Test with class.""" + self.assertFalse(is_injection(Injection)) + + def test_with_string(self): + """Test with string.""" + self.assertFalse(is_injection('some_string')) + + def test_with_object(self): + """Test with object.""" + self.assertFalse(is_injection(object())) + + +class IsInitArgInjectionTest(unittest.TestCase): + + """`is_init_arg_injection()` test cases.""" + + def test_with_instance(self): + """Test with instance.""" + self.assertTrue(is_init_arg_injection(InitArg('name', 'value'))) + + def test_with_class(self): + """Test with class.""" + self.assertFalse(is_init_arg_injection(InitArg)) + + def test_with_parent_class(self): + """Test with parent class.""" + self.assertFalse(is_init_arg_injection(Injection)) + + def test_with_string(self): + """Test with string.""" + self.assertFalse(is_init_arg_injection('some_string')) + + def test_with_object(self): + """Test with object.""" + self.assertFalse(is_init_arg_injection(object())) + + +class IsAttributeInjectionTest(unittest.TestCase): + + """`is_attribute_injection()` test cases.""" + + def test_with_instance(self): + """Test with instance.""" + self.assertTrue(is_attribute_injection(Attribute('name', 'value'))) + + def test_with_class(self): + """Test with class.""" + self.assertFalse(is_attribute_injection(Attribute)) + + def test_with_parent_class(self): + """Test with parent class.""" + self.assertFalse(is_attribute_injection(Injection)) + + def test_with_string(self): + """Test with string.""" + self.assertFalse(is_attribute_injection('some_string')) + + def test_with_object(self): + """Test with object.""" + self.assertFalse(is_attribute_injection(object())) + + +class IsMethodInjectionTest(unittest.TestCase): + + """`is_method_injection()` test cases.""" + + def test_with_instance(self): + """Test with instance.""" + self.assertTrue(is_method_injection(Method('name', 'value'))) + + def test_with_class(self): + """Test with class.""" + self.assertFalse(is_method_injection(Method)) + + def test_with_parent_class(self): + """Test with parent class.""" + self.assertFalse(is_method_injection(Injection)) + + def test_with_string(self): + """Test with string.""" + self.assertFalse(is_method_injection('some_string')) + + def test_with_object(self): + """Test with object.""" + self.assertFalse(is_method_injection(object()))