changed dummy class to a dummy class factory

patterns/creational.py

@@ -0,0 +1,4 @@
+
+
+class Singleton(object):
+    pass

tests/creational_tests/test_singleton.py

@@ -1,5 +1,7 @@
 from unittest import TestCase
-from creational import singleton
+
+from tests.utils.dummy_class import dummy_factory
+from patterns.creational import Singleton
 
 
 class SingletonTestCase(TestCase):
@@ -9,6 +11,16 @@ class SingletonTestCase(TestCase):
     def setUp(self):
         """
         Initialize testing data.
-
-        :return:
         """
+        self.dummy_class = dummy_factory(base_class=Singleton, attributes={}, functions={})
+
+    def test_id(self):
+        """
+        Test the id's of two singleton instances.
+
+        @raise AssertionError: If the test fails.
+        """
+        dummy = self.dummy_class()
+        dummy_2 = self.dummy_class()
+
+        self.assertEquals(id(dummy), id(dummy_2))

tests/test_utils.py

@@ -1,5 +1,5 @@
 from unittest import TestCase
-from tests.utils.dummy_class import DummyClass
+from tests.utils.dummy_class import dummy_factory
 
 
 class DummyClassTestCase(TestCase):
@@ -21,30 +21,26 @@ class DummyClassTestCase(TestCase):
 
         @raise AssertionError: If the test fails.
         """
-        dummy = DummyClass(attributes={'a': self.a, 'b': self.b},
+        dummy_class = dummy_factory(base_class=object,
+                                    attributes={'a': self.a, 'b': self.b},
                                     functions={'add': self.add_function, 'subtract': self.subtract_function})
 
+        dummy = dummy_class()
+
         self.assertEquals(self.a, dummy.a)
         self.assertEquals(self.b, dummy.b)
 
-    def test_invalid_init(self):
-        """
-        Test the __init__ method with invalid parameters.
-
-        @raise AssertionError if the test fails:
-        """
-        with self.assertRaises(ValueError):
-            DummyClass(attributes={'a': self.add_function}, functions={'add': self.a})
-
     def test_add(self):
         """
         Test a dummy class initialized with an add function.
 
         @raise AssertionError: If the test fails.
         """
-        dummy = DummyClass(attributes={'a': self.a, 'b': self.b},
+        dummy_class = dummy_factory(base_class=object,
+                                    attributes={'a': self.a, 'b': self.b},
                                     functions={'add': self.add_function})
 
+        dummy = dummy_class()
         self.assertEquals(15, dummy.add())
 
     def test_subtract(self):
@@ -53,11 +49,53 @@ class DummyClassTestCase(TestCase):
 
         @raise AssertionError: If the test fails.
         """
-        dummy = DummyClass(attributes={'a': self.a, 'b': self.b},
+        dummy_class = dummy_factory(base_class=object,
+                                    attributes={'a': self.a, 'b': self.b},
                                     functions={'subtract': self.subtract_function})
 
+        dummy = dummy_class()
         self.assertEquals(5, dummy.subtract())
 
+    def test_instances(self):
+        """
+        Test multiple instances.
+
+        @raise AssertionError: If the test fails.
+        """
+        dummy_class_one = dummy_factory(base_class=object,
+                                        attributes={'a': self.a, 'b': self.b},
+                                        functions={'add': self.add_function})
+
+        dummy_class_one_instance_one = dummy_class_one()
+        dummy_class_one_instance_two = dummy_class_one()
+
+        self.assertEquals(dummy_class_one_instance_one.a, dummy_class_one_instance_two.a)
+        self.assertEquals(dummy_class_one_instance_one.b, dummy_class_one_instance_two.b)
+        self.assertEquals(dummy_class_one_instance_one.add(), dummy_class_one_instance_two.add())
+
+    def test_classes(self):
+        """
+        Test multiple classes.
+
+        @raise AssertionError: If the test fails.
+        """
+        dummy_class_one = dummy_factory(base_class=object,
+                                        attributes={'a': self.a, 'b': self.b},
+                                        functions={'add': self.add_function})
+        dummy_class_two = dummy_factory(base_class=object,
+                                        attributes={'a': 30, 'b': 10},
+                                        functions={'subtract': self.subtract_function})
+
+        self.assertNotEquals(dummy_class_one.a, dummy_class_two.a)
+        self.assertNotEquals(dummy_class_one.b, dummy_class_two.b)
+
+        assert (hasattr(dummy_class_one, 'add'))
+        assert (not hasattr(dummy_class_one, 'subtract'))
+
+        assert (hasattr(dummy_class_two, 'subtract'))
+        assert (not hasattr(dummy_class_two, 'add'))
+
+
 
 
 

tests/utils/dummy_class.py

@@ -1,27 +1,24 @@
 from types import MethodType
 
 
-class DummyClass(object):
+def dummy_factory(base_class, attributes, functions):
+
+    class DummyClass(base_class):
         """
         Class representing dummy data.
         """
-    def __init__(self, attributes, functions):
+        pass
-        """
-        Initialize a new DummyClass instance.
 
-        @param attributes: A dictionary of instance variables for this dummy instance.
-        @type attributes: dict
-        @param functions: A dictionary of functions for this dummy instance.
-        @type functions: dict
-        """
     for key, value in attributes.items():
         if callable(value):
             raise ValueError
         else:
-                setattr(self, key, value)
+            setattr(DummyClass, key, value)
 
     for key, value in functions.items():
         if not callable(value):
             raise ValueError
         else:
-                setattr(self, key, MethodType(value, self))
+            setattr(DummyClass, key, MethodType(value, DummyClass))
+
+    return DummyClass