Implemented Singleton metaclass

patterns/creational.py

@@ -1,4 +1,19 @@
 
 
-class Singleton(object):
-    pass
+class Singleton(type):
+    """
+    Singleton Metaclass.
+
+    Enforces any object using this metaclass to only create a single instance.
+    """
+    __instance = None
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Override the __call__ method to make sure only one instance is created.
+        """
+        if cls.__instance is None:
+            cls.__instance = type.__call__(cls, *args, **kwargs)
+
+        return cls.__instance
+

tests/creational_tests/test_singleton.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 
-from tests.utils.dummy_class import dummy_factory
+from tests.utils.dummy import dummy_class_factory
 from patterns.creational import Singleton
 
 
@@ -12,15 +12,40 @@ class SingletonTestCase(TestCase):
         """
         Initialize testing data.
         """
-        self.dummy_class = dummy_factory(base_class=Singleton, attributes={}, functions={})
+        self.dummy_class_one = dummy_class_factory(meta_class=Singleton,
+                                                   attributes={},
+                                                   functions={})
 
-    def test_id(self):
+        self.dummy_class_two = dummy_class_factory(meta_class=Singleton,
+                                                   attributes={},
+                                                   functions={})
+
+    def test_single(self):
         """
-        Test the id's of two singleton instances.
+        Test instances from a single singleton class.
 
         @raise AssertionError: If the test fails.
         """
-        dummy = self.dummy_class()
-        dummy_2 = self.dummy_class()
+        dummy_one = self.dummy_class_one()
+        dummy_two = self.dummy_class_one()
+
+        self.assertEquals(id(dummy_one), id(dummy_two))
+
+    def test_multiple(self):
+        """
+        Test instances from multiple singleton classes.
+
+        @raise AssertionError: If the test fails.
+        """
+        dummy_class_one_instance_one = self.dummy_class_one()
+        dummy_class_one_instance_two = self.dummy_class_one()
+
+        dummy_class_two_instance_one = self.dummy_class_two()
+        dummy_class_two_instance_two = self.dummy_class_two()
+
+        self.assertEquals(id(dummy_class_one_instance_one), id(dummy_class_one_instance_two))
+        self.assertEquals(id(dummy_class_two_instance_one), id(dummy_class_two_instance_two))
+
+        self.assertNotEquals(id(dummy_class_one_instance_one), id(dummy_class_two_instance_one))
+        self.assertNotEquals(id(dummy_class_one_instance_two), id(dummy_class_two_instance_two))
 
-        self.assertEquals(id(dummy), id(dummy_2))

tests/test_utils.py

@@ -1,5 +1,6 @@
 from unittest import TestCase
-from tests.utils.dummy_class import dummy_factory
+from tests.utils.dummy import dummy_class_factory
+from abc import ABCMeta, ABC
 
 
 class DummyClassTestCase(TestCase):
@@ -21,9 +22,8 @@ class DummyClassTestCase(TestCase):
 
         @raise AssertionError: If the test fails.
         """
-        dummy_class = dummy_factory(base_class=object,
-                                    attributes={'a': self.a, 'b': self.b},
-                                    functions={'add': self.add_function, 'subtract': self.subtract_function})
+        dummy_class = dummy_class_factory(attributes={'a': self.a, 'b': self.b},
+                                          functions={'add': self.add_function, 'subtract': self.subtract_function})
 
         dummy = dummy_class()
 
@@ -36,9 +36,8 @@ class DummyClassTestCase(TestCase):
 
         @raise AssertionError: If the test fails.
         """
-        dummy_class = dummy_factory(base_class=object,
-                                    attributes={'a': self.a, 'b': self.b},
-                                    functions={'add': self.add_function})
+        dummy_class = dummy_class_factory(attributes={'a': self.a, 'b': self.b},
+                                          functions={'add': self.add_function})
 
         dummy = dummy_class()
         self.assertEquals(15, dummy.add())
@@ -49,9 +48,8 @@ class DummyClassTestCase(TestCase):
 
         @raise AssertionError: If the test fails.
         """
-        dummy_class = dummy_factory(base_class=object,
-                                    attributes={'a': self.a, 'b': self.b},
-                                    functions={'subtract': self.subtract_function})
+        dummy_class = dummy_class_factory(attributes={'a': self.a, 'b': self.b},
+                                          functions={'subtract': self.subtract_function})
 
         dummy = dummy_class()
         self.assertEquals(5, dummy.subtract())
@@ -62,9 +60,8 @@ class DummyClassTestCase(TestCase):
 
         @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 = dummy_class_factory(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()
@@ -79,12 +76,10 @@ class DummyClassTestCase(TestCase):
 
         @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})
+        dummy_class_one = dummy_class_factory(attributes={'a': self.a, 'b': self.b},
+                                              functions={'add': self.add_function})
+        dummy_class_two = dummy_class_factory(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)
@@ -95,6 +90,29 @@ class DummyClassTestCase(TestCase):
         assert (hasattr(dummy_class_two, 'subtract'))
         assert (not hasattr(dummy_class_two, 'add'))
 
+    def test_meta_class(self):
+        """
+        Test assigning a metaclass.
+
+        @raise AssertionError: If the test fails.
+        """
+        dummy_class = dummy_class_factory(attributes={'a': self.a, 'b': self.b},
+                                          functions={'add': self.add_function},
+                                          meta_class=ABCMeta)
+
+        self.assertEquals(ABCMeta, dummy_class.__class__)
+
+    def test_base_class(self):
+        """
+        Test assigning a base class.
+
+        @raise AssertionError: If the test fails
+        """
+        dummy_class = dummy_class_factory(attributes={'a': self.a, 'b': self.b},
+                                          functions={'add': self.add_function},
+                                          base_class=ABC)
+
+        self.assertEquals(ABC, dummy_class.__base__)
 
 
 

tests/utils/dummy.py

@@ -1,13 +1,14 @@
 from types import MethodType
 
 
-def dummy_factory(base_class, attributes, functions):
+def dummy_class_factory(attributes, functions, base_class=object, meta_class=type):
 
-    class DummyClass(base_class):
+    class DummyClass(base_class, metaclass=meta_class):
         """
         Class representing dummy data.
         """
-        pass
+        def __init__(self):
+            pass
 
     for key, value in attributes.items():
         if callable(value):
@@ -21,4 +22,4 @@ def dummy_factory(base_class, attributes, functions):
         else:
             setattr(DummyClass, key, MethodType(value, DummyClass))
 
-    return DummyClass
+    return DummyClass