facade

Author: jgrynczewski

3_structural/05_facade/README.md

@@ -1,55 +1,79 @@
 # 🏠 Facade - SmartHome System
 
-**Difficulty**: easy
-**Time**: 10 minutes
-**Focus**: Facade pattern - simplifying complex subsystems
+**Poziom**: łatwy
+**Cel**: Facade - uproszczenie interfejsu do złożonych podsystemów
 
 ## 🎯 Zadanie
-Zaimplementuj `SmartHomeFacade` - upraszcza sterowanie wieloma urządzeniami.
+Zaimplementuj wzorzec Facade dla systemu inteligentnego domu. `SmartHomeFacade` upraszcza sterowanie wieloma urządzeniami poprzez wystawienie prostych metod wysokiego poziomu.
 
 ## 📋 Wymagania
-- [ ] `SmartHomeFacade.__init__()` - tworzy Light, Thermostat, Security, TV
-- [ ] `evening_mode()` - dim(50), temp(22), disarm, TV on
-- [ ] `leaving_home()` - light off, temp(18), arm, TV off
+- [ ] Przechodzą doctesty
+- [ ] Przechodzą testy jednostkowe (pytest)
+- [ ] `SmartHomeFacade` tworzy wszystkie podsystemy w konstruktorze
+- [ ] Metoda `evening_mode()` koordynuje wszystkie podsystemy
+- [ ] Metoda `leaving_home()` koordynuje wszystkie podsystemy
 
 ## 🚀 Jak zacząć
-```bash
-cd day2_structural/05_facade
-pytest test_facade.py -v
-```
+1. Otwórz `starter.py`
+2. Uruchom testy (powinny failować):
+   - Doctests: `python -m doctest starter.py -v`
+   - Pytest: `pytest` (lub `pytest -v` dla bardziej szczegółowego outputu)
+3. Podsystemy (`Light`, `Thermostat`, `SecuritySystem`, `TV`) są już gotowe
+4. Zaimplementuj klasę `SmartHomeFacade`:
+   - Konstruktor tworzy instancje wszystkich podsystemów
+   - Metoda `evening_mode()` - wywołuje odpowiednie metody podsystemów
+   - Metoda `leaving_home()` - wywołuje odpowiednie metody podsystemów
+5. Uruchom testy ponownie (teraz powinny przejść)
+6. Gdy wszystkie testy przechodzą:
+   ```bash
+   git add .
+   git commit -m "Complete Facade pattern"
+   git push
+   ```
+7. Sprawdź wynik w GitHub Actions
 
 ## 💡 Facade w pigułce
 
-**Upraszcza interfejs do złożonego podsystemu**
+**Facade deleguje pracę do wielu podsystemów i upraszcza interfejs**
+
+### Jak to działa:
+1. Facade tworzy instancje wszystkich podsystemów w konstruktorze
+2. Klient wywołuje jedną metodę Facade (np. `evening_mode()`)
+3. Facade koordynuje wywołania do wielu podsystemów w odpowiedniej kolejności
+
+### Kluczowy moment:
+```python
+def evening_mode(self) -> str:
+    # Facade wywołuje wiele podsystemów
+    result1 = self.light.dim(50)
+    result2 = self.thermostat.set_temperature(22)
+    # ... itd
+```
+
+Klient nie musi znać `Light`, `Thermostat`, `SecuritySystem`, `TV` - tylko `SmartHomeFacade`.
+
+---
 
-❌ **Źle** (klient zna wszystkie podsystemy):
+### ❌ Bez wzorca:
 ```python
-# Klient wywołuje 4 klasy ❌
+# Klient zarządza wszystkim
 light = Light()
 thermostat = Thermostat()
 security = SecuritySystem()
 tv = TV()
 
-# Klient musi pamiętać sekwencję ❌
+# Musi pamiętać sekwencję
 light.dim(50)
 thermostat.set_temperature(22)
 security.disarm()
 tv.turn_on()
 ```
 
-✅ **Dobrze** (Facade ukrywa złożoność):
+### ✅ Z wzorcem (Facade):
 ```python
-home = SmartHomeFacade()  # Jedna klasa ✅
-home.evening_mode()       # Jedna metoda ✅
-
-# Facade wywoła wszystkie 4 podsystemy w odpowiedniej kolejności
+home = SmartHomeFacade()
+home.evening_mode()
+# Facade zarządza wszystkim wewnętrznie
 ```
 
-**Korzyść**: Klient nie zna Light/Thermostat/Security/TV - tylko Facade.
-
-**Kiedy stosować**:
-- Uproszczenie złożonego API
-- Ukrycie legacy code
-- Jeden punkt wejścia do wielu systemów
-
-Sprawdź `solution_facade.py` po wykonaniu.
+**Korzyść**: Klient wywołuje jedną metodę zamiast czterech, bez znajomości implementacji podsystemów.

3_structural/05_facade/problem.py

@@ -0,0 +1,114 @@
+"""
+❌ PROBLEM: Klient bezpośrednio zarządza wieloma podsystemami
+
+Rozwiązanie bez wzorca Facade:
+- Klient musi znać wszystkie klasy podsystemów (Light, Thermostat, Security, TV)
+- Klient musi pamiętać sekwencję wywołań dla każdej akcji
+- Duplikacja logiki w wielu miejscach kodu klienta
+"""
+
+
+class Light:
+    """Podsystem - oświetlenie"""
+
+    def turn_on(self) -> str:
+        return "Light turned ON"
+
+    def turn_off(self) -> str:
+        return "Light turned OFF"
+
+    def dim(self, level: int) -> str:
+        return f"Light dimmed to {level}%"
+
+
+class Thermostat:
+    """Podsystem - termostat"""
+
+    def set_temperature(self, temp: int) -> str:
+        return f"Thermostat set to {temp}°C"
+
+
+class SecuritySystem:
+    """Podsystem - alarm"""
+
+    def arm(self) -> str:
+        return "Security system ARMED"
+
+    def disarm(self) -> str:
+        return "Security system DISARMED"
+
+
+class TV:
+    """Podsystem - telewizor"""
+
+    def turn_on(self) -> str:
+        return "TV turned ON"
+
+    def turn_off(self) -> str:
+        return "TV turned OFF"
+
+
+# ❌ Przykład użycia - klient zarządza wszystkim
+if __name__ == "__main__":
+    # ❌ PROBLEM: Klient musi stworzyć wszystkie podsystemy
+    light = Light()
+    thermostat = Thermostat()
+    security = SecuritySystem()
+    tv = TV()
+
+    # ❌ PROBLEM: Klient musi pamiętać sekwencję dla "trybu wieczornego"
+    print("=== Evening Mode ===")
+    print(light.dim(50))
+    print(thermostat.set_temperature(22))
+    print(security.disarm())
+    print(tv.turn_on())
+
+    # ❌ PROBLEM: Klient musi pamiętać inną sekwencję dla "wychodzenia"
+    print("\n=== Leaving Home ===")
+    print(light.turn_off())
+    print(thermostat.set_temperature(18))
+    print(security.arm())
+    print(tv.turn_off())
+
+    # ❌ Każde miejsce w kodzie, które potrzebuje "evening mode"
+    # musi powtarzać te 4 linie
+    #
+    # ❌ Zmiana sekwencji wymaga edycji w wielu miejscach
+    #
+    # ❌ Nowy programista musi znać wszystkie 4 klasy podsystemów
+
+
+"""
+Jakie problemy rozwiązuje Facade?
+
+1. ❌ Zbyt wiele zależności
+   - Klient zależy od Light, Thermostat, SecuritySystem, TV
+   - Dodanie nowego podsystemu wymaga zmian w kliencie
+   - Wysokie sprzężenie (tight coupling)
+
+2. ❌ Duplikacja logiki
+   - "Evening mode" może być używany w 10 miejscach
+   - Każde miejsce powtarza te same 4 wywołania
+   - Zmiana sekwencji = edycja 10 miejsc
+
+3. ❌ Trudne utrzymanie
+   - Klient musi znać szczegóły implementacji podsystemów
+   - Klient musi pamiętać prawidłową kolejność wywołań
+   - Łatwo o błąd (zapomnienie jednego kroku)
+
+4. ❌ Brak abstrakcji
+   - Klient operuje na niskim poziomie (dim, set_temperature)
+   - Brak operacji wysokiego poziomu (evening_mode, leaving_home)
+   - Kod trudny do zrozumienia
+
+5. ❌ Trudne testowanie
+   - Testowanie klienta wymaga mockowania 4 klas
+   - Każdy test musi setupować wszystkie podsystemy
+   - Duża liczba zależności
+
+Jak Facade to rozwiązuje?
+1. SmartHomeFacade ukrywa wszystkie podsystemy
+2. Klient wywołuje home.evening_mode() zamiast 4 metod
+3. Logika sekwencji w jednym miejscu (Facade)
+4. Łatwe testowanie - mockujemy tylko Facade
+"""