added ordering of orders

backend/database.py

@@ -25,8 +25,8 @@ class OrderDatabase:
         return order
     
     def get_all_orders(self) -> List[Order]:
-        """Get all orders."""
+        """Get all orders sorted by order date (oldest first)."""
-        return list(self.orders.values())
+        return sorted(self.orders.values(), key=lambda order: order.order_date)
     
     def get_order_by_id(self, order_id: str) -> Optional[Order]:
         """Get a specific order by ID."""

backend/test_automated.py

@@ -143,6 +143,42 @@ class TestTschunkOrderAPI:
         order_ids = [order["id"] for order in orders]
         assert create_response.json()["id"] in order_ids
 
+    def test_orders_sorted_by_date(self, client):
+        """Test dass Bestellungen nach Bestelldatum sortiert sind (älteste zuerst)"""
+        # Erstelle mehrere Bestellungen mit kurzen Pausen
+        import time
+        
+        orders = []
+        for i in range(3):
+            order_data = {
+                "drinks": [
+                    {
+                        "drink_type": "Tschunk",
+                        "mate_type": "Club Mate",
+                        "quantity": i + 1,
+                        "notes": f"Test-Bestellung {i + 1}"
+                    }
+                ]
+            }
+            response = client.post("/orders", json=order_data)
+            assert response.status_code == 201
+            orders.append(response.json())
+            time.sleep(0.1)  # Kurze Pause zwischen Bestellungen
+        
+        # Hole alle Bestellungen
+        response = client.get("/orders")
+        assert response.status_code == 200
+        
+        all_orders = response.json()
+        
+        # Prüfe, dass Bestellungen nach order_date sortiert sind (älteste zuerst)
+        order_dates = [order["order_date"] for order in all_orders if order["id"] in [o["id"] for o in orders]]
+        assert len(order_dates) == 3
+        
+        # Prüfe Sortierung (order_dates sollten aufsteigend sein)
+        for i in range(len(order_dates) - 1):
+            assert order_dates[i] <= order_dates[i + 1], f"Bestellungen sind nicht korrekt sortiert: {order_dates[i]} > {order_dates[i + 1]}"
+    
     def test_delete_order_success(self, client, sample_order):
         """Test erfolgreiche Bestelllöschung"""
         # Erstelle zuerst eine Bestellung
@@ -465,6 +501,94 @@ class TestWebSocket:
         websocket_manager.disconnect(mock_ws2)
         websocket_manager.disconnect(mock_ws3)
 
+    @pytest.mark.asyncio
+    async def test_websocket_orders_sorted(self):
+        """Test dass WebSocket-Broadcasts sortierte Bestellungen senden"""
+        from websocket_manager import websocket_manager
+        from database import db  # Verwende globale Datenbank-Instanz
+        from models import Drink, DrinkType, MateType
+        
+        # Erstelle einen Test-WebSocket
+        class MockWebSocket:
+            def __init__(self):
+                self.messages = []
+                self.closed = False
+            
+            async def accept(self):
+                pass
+            
+            async def send_text(self, message):
+                self.messages.append(message)
+            
+            async def receive_text(self):
+                return "ping"
+            
+            async def close(self):
+                self.closed = True
+        
+        # Erstelle mehrere Bestellungen in der globalen Datenbank
+        import asyncio
+        
+        orders = []
+        for i in range(3):
+            drinks = [
+                Drink(
+                    drink_type=DrinkType.TSCHUNK,
+                    mate_type=MateType.CLUB_MATE,
+                    quantity=i + 1,
+                    notes=f"Test-Bestellung {i + 1}"
+                )
+            ]
+            order = await db.create_order(drinks)
+            orders.append(order)
+            await asyncio.sleep(0.1)  # Kurze Pause zwischen Bestellungen
+        
+        # Verbinde Mock-WebSocket (sollte all_orders broadcast auslösen)
+        mock_ws = MockWebSocket()
+        await websocket_manager.connect(mock_ws)
+        
+        # Simuliere den WebSocket-Endpunkt: Sende alle Bestellungen
+        all_orders = [order.model_dump() for order in db.get_all_orders()]
+        await websocket_manager.broadcast_all_orders(all_orders)
+        
+        # Prüfe, dass die all_orders Nachricht gesendet wurde
+        assert len(mock_ws.messages) >= 1
+        
+        # Finde die "all_orders" Nachricht
+        all_orders_message = None
+        for message in mock_ws.messages:
+            try:
+                data = json.loads(message)
+                if data.get("type") == "all_orders":
+                    all_orders_message = data
+                    break
+            except json.JSONDecodeError:
+                continue
+        
+        assert all_orders_message is not None
+        assert "orders" in all_orders_message
+        
+        # Prüfe, dass Bestellungen sortiert sind (älteste zuerst)
+        orders_data = all_orders_message["orders"]
+        assert len(orders_data) >= 3
+        
+        # Extrahiere unsere Test-Bestellungen
+        test_order_ids = [order.id for order in orders]
+        test_orders = [order for order in orders_data if order["id"] in test_order_ids]
+        
+        assert len(test_orders) == 3
+        
+        # Prüfe Sortierung nach order_date
+        order_dates = [order["order_date"] for order in test_orders]
+        for i in range(len(order_dates) - 1):
+            assert order_dates[i] <= order_dates[i + 1], f"WebSocket-Bestellungen sind nicht korrekt sortiert: {order_dates[i]} > {order_dates[i + 1]}"
+        
+        # Cleanup: Lösche Test-Bestellungen
+        for order in orders:
+            await db.delete_order(order.id)
+        
+        websocket_manager.disconnect(mock_ws)
+
 
 class TestDatabase:
     """Test-Klasse für Datenbankfunktionalität"""