added unittest folder and tests, added factory pattern, added results in html format

Author: robertbenson

Test Results - .html

@@ -0,0 +1,82 @@
+# Define a Pizza interface
+from abc import abstractmethod
+
+
+class Pizza:
+    @abstractmethod
+    def prepare(self):
+        return "Concrete implementation required"
+
+
+    @abstractmethod
+    def bake(self):
+        pass
+
+    @abstractmethod
+    def cut(self):
+        pass
+
+    @abstractmethod
+    def box(self):
+        pass
+
+# Concrete Pizza classes
+class MargheritaPizza(Pizza):
+
+    def prepare(self):
+        print("Preparing Margherita Pizza")
+
+    def bake(self):
+        print("Baking Margherita Pizza")
+
+    def cut(self):
+        print("Cutting Margherita Pizza")
+
+    def box(self):
+        print("Boxing Margherita Pizza")
+
+class PepperoniPizza(Pizza):
+    def prepare(self):
+        print("Preparing Pepperoni Pizza")
+
+    def bake(self):
+        print("Baking Pepperoni Pizza")
+
+    def cut(self):
+        print("Cutting Pepperoni Pizza")
+
+    def box(self):
+        print("Boxing Pepperoni Pizza")
+
+# Pizza Factory
+class PizzaFactory:
+    """It creates and returns an instance of the appropriate subclass based
+    on the pizza_type parameter."""
+    def create_pizza(self, pizza_type):
+        if pizza_type == 'Margherita':
+            return MargheritaPizza()
+        elif pizza_type == 'Pepperoni':
+            return PepperoniPizza()
+        else:
+            raise ValueError("Invalid pizza type")
+
+# Client code
+if __name__ == "__main__":
+    # Creating a Margherita Pizza using the factory
+    factory = PizzaFactory()
+    margherita_pizza = factory.create_pizza('Margherita')
+
+    # Using the created Margherita Pizza
+    margherita_pizza.prepare()
+    margherita_pizza.bake()
+    margherita_pizza.cut()
+    margherita_pizza.box()
+
+    # Creating a Pepperoni Pizza using the factory
+    pepperoni_pizza = factory.create_pizza('Pepperoni')
+
+    # Using the created Pepperoni Pizza
+    pepperoni_pizza.prepare()
+    pepperoni_pizza.bake()
+    pepperoni_pizza.cut()
+    pepperoni_pizza.box()

factory.py

@@ -1,7 +1,7 @@
 # Using Classes for encapsulation compared to global variables
 
-This is quick reference for using alternatives to global variables. 
-It is not a guide as to which pattern is the best.
+This is my quick reference for using alternatives to global variables. 
+It is not by any means a guide as to which pattern is the best.
 
 The choice between using classes and encapsulation versus global variables depends on the specific requirements and design principles of your code. 
 

readme.md

@@ -0,0 +1,31 @@
+import unittest
+
+from factory import PizzaFactory, MargheritaPizza, PepperoniPizza, Pizza
+
+
+# Assume you have a PizzaFactory class and different Pizza subclasses (e.g.,
+# MargheritaPizza, PepperoniPizza)
+
+class TestPizzaFactory(unittest.TestCase):
+    def test_create_margherita_pizza(self):
+        pizza_factory = PizzaFactory()
+        pizza = pizza_factory.create_pizza("Margherita")
+        self.assertIsInstance(pizza, MargheritaPizza)
+        # Add more specific assertions related to MargheritaPizza creation if needed
+
+    def test_create_pepperoni_pizza(self):
+        pizza_factory = PizzaFactory()
+        pizza = pizza_factory.create_pizza("Pepperoni")
+        self.assertIsInstance(pizza, PepperoniPizza)
+        # Add more specific assertions related to PepperoniPizza creation if needed
+
+
+    def test_abstract_class_instantiation(self):
+        with self.assertRaises(Exception) as context:
+            abstract_instance= Pizza()
+            self.assertEqual(str(context.exception), "Concrete "
+                                                     "implementation required")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_factory.py

@@ -2,7 +2,7 @@
 from monostate import Monostate
 
 
-class MyTestCase(unittest.TestCase):
+class Borg_TestCase(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.borg1 = Monostate()

tests/test_monostate.py

@@ -3,7 +3,7 @@
 from observer import Subscriber
 
 
-class MyTestCase(unittest.TestCase):
+class Observer_TestCase(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         print("setUpClass")
@@ -21,11 +21,13 @@ def test_register_2_observers(self):
         self.assertEqual(len(self.channelPublisher.subscribers), 2)
 
     def test_sequence(self):
-        """ register , unregister, notify"""
+        """ notify,
+        unregister ,
+        unregister,
+        notify"""
         self.channelPublisher.notify()
         self.channelPublisher.unregister(self.bob)
         self.assertEqual(len(self.channelPublisher.subscribers), 1)
-        subscribers = self.channelPublisher.subscribers
 
         for subscriber in self.channelPublisher.subscribers:
             self.assertEqual(subscriber.name, "FooBar")
@@ -38,7 +40,5 @@ def test_sequence(self):
         self.channelPublisher.unregister(self.FooBar)
         self.assertNotIn(self.FooBar, self.channelPublisher.subscribers)
 
-        # assert that no more subscibers are left
+        # verify that no more subscribers are left
         self.assertEqual(len(self.channelPublisher.subscribers), 0)
-
-

tests/test_observer.py

@@ -2,7 +2,7 @@
 from singleton import Singleton
 
 
-class MyTestCase(unittest.TestCase):
+class Singleton_TestCase(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.s1 = Singleton.get_instance()