refactor builder, tests and readme

Author: robertbenson

builder.py

@@ -1,24 +1,34 @@
 # Product class
 class Computer:
-    def __init__(self, CPU, RAM, storage, GPU):
-        self.CPU = CPU
-        self.RAM = RAM
+    def __init__(self, cpu, ram, storage, gpu, screen):
+        self.CPU = cpu
+        self.RAM = ram
         self.storage = storage
-        self.GPU = GPU
+        self.GPU = gpu
+        self.Screen = screen
+
+    def __str__(self):
+        return (((f"\nHigh End Computer : " + str(self.CPU) +
+                  "," + str(self.RAM)) + ","
+                 + str(self.storage)) + ","
+                + str(self.Screen))
 
 
 # Builder interface
 class ComputerBuilder:
-    def build_CPU(self):
+    def build_cpu(self):
         pass
 
-    def build_RAM(self):
+    def build_ram(self):
         pass
 
     def build_storage(self):
         pass
 
-    def build_GPU(self):
+    def build_gpu(self):
+        pass
+
+    def build_screen(self):
         pass
 
     def get_computer(self):
@@ -29,34 +39,45 @@ def get_computer(self):
 class HighEndComputerBuilder(ComputerBuilder):
     def __init__(self):
         self.computer = Computer("Intel i9", "32GB", "1TB SSD",
-                                 "NVIDIA RTX 3090")
+                                 "NVIDIA Quadro",
+                                 screen="17 Inch touch screen")
 
-    def build_CPU(self):
+    def build_cpu(self):
         self.computer.CPU = "Intel i9"
 
-    def build_RAM(self):
+    def build_ram(self):
         self.computer.RAM = "64GB"
 
     def build_storage(self):
         self.computer.storage = "2TB SSD"
 
-    def build_GPU(self):
-        self.computer.GPU = "NVIDIA RTX 3090"
+    def build_gpu(self):
+        self.computer.GPU = "NVIDIA Quadro"
+
+    def build_screen(self):
+        self.computer.Screen = "17 Inch touch screen"
 
     def get_computer(self):
         return self.computer
 
+    def __str__(self):
+        return (((f"\nHigh End Computer : " + str(self.computer.CPU) +
+                  "," + str(self.computer.RAM)) + ","
+                 + str(self.computer.storage)) + ","
+                + str(self.computer.Screen))
+
 
 # Director
 class ComputerDirector:
     def __init__(self, builder):
         self.builder = builder
 
     def construct_computer(self):
-        self.builder.build_CPU()
-        self.builder.build_RAM()
+        self.builder.build_cpu()
+        self.builder.build_ram()
         self.builder.build_storage()
-        self.builder.build_GPU()
+        self.builder.build_gpu()
+        self.builder.build_screen()
 
 
 # Client code
@@ -71,3 +92,4 @@ def construct_computer(self):
 print(f"RAM: {computer.RAM}")
 print(f"Storage: {computer.storage}")
 print(f"GPU: {computer.GPU}")
+print(f"Screen: {computer.Screen}")

readme.md

@@ -41,7 +41,6 @@ While classes and encapsulation are generally recommended,
 it's essential to consider the specific requirements of your project. 
 In some cases, using global variables might be appropriate, but it's crucial to be mindful of the potential drawbacks mentioned above. Striking a balance and following good design principles will contribute to more maintainable and scalable code.
 
-
 ## Singleton Pattern
 
 
@@ -55,8 +54,19 @@ The monostate pattern will create instances or objects with their own identity t
 It is often referred to as the Borg pattern in reference to The Borg in Star Trek. 
 While being individuals in their own right, they all share the same collective consciousness or shared state.
 
+## Other Useful Patterns
+
 ## Factory Pattern
 
 The Factory Pattern is to define an interface for creating an object, but leave the choice of its type to the subclasses, 
 deferring the instantiation to the subclasses. Objects are created by calling a factory method 
-instead of calling a constructor.
+instead of calling a constructor.
+
+## Builder Pattern
+
+The Builder Pattern is a creational design pattern used to construct complex objects step by step. 
+It separates the construction of a complex object from its representation. i.e. keep the process of putting 
+it together separate from how it's actually represented or used in the program. This way, the same 
+construction process can create different representations.
+Imagine you have an order for a new laptop. You will pick the processor, ram, screen size, memory , mouse, warranty and many other options.
+The builder pattern will allow for many different laptop variations.

tests/test_builder.py

@@ -0,0 +1,22 @@
+import unittest
+
+from builder import HighEndComputerBuilder
+from factory import PizzaFactory, MargheritaPizza, PepperoniPizza, Pizza
+
+
+# Assume you have a PizzaFactory class and different Pizza subclasses (e.g.,
+# MargheritaPizza, PepperoniPizza)
+
+class TestBuilder(unittest.TestCase):
+    def test_create_HighEndComputer(self):
+        builder = HighEndComputerBuilder()
+        computer= builder.get_computer()
+        self.assertEqual(str(builder), "\nHigh End Computer : Intel i9,32GB,1TB SSD,17 Inch touch screen")
+        self.assertEqual(str(computer.CPU), "Intel i9")
+        self.assertEqual(str(computer.RAM), "32GB")
+        self.assertEqual(str(computer.storage), "1TB SSD")
+        self.assertEqual(str(computer.GPU), "NVIDIA Quadro")
+        self.assertEqual(str(computer.Screen), "17 Inch touch screen")
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_factory.py

@@ -25,7 +25,7 @@ def test_instantiation_abtract_class_error(self):
         with self.assertRaises(TypeError):
             # Attempt to instantiate the abstract class, which should raise
             # a TypeError
-            instance = Pizza()
+            abstract_class = Pizza()
 
 
 if __name__ == '__main__':