Claude...

Author: venantvr

src/pubsub_ws.py

@@ -16,15 +16,15 @@
 logger = logging.getLogger(__name__)
 
 
-# --- DÉBUT MODIFICATION POUR LA GESTION DE LA DB ET LES TESTS ---
+# --- START MODIFICATION FOR DB MANAGEMENT AND TESTS ---
 def init_db(db_name: str, connection: Optional[sqlite3.Connection] = None) -> None:
     """Initialize the SQLite database and run migrations if necessary."""
     if connection:
         conn = connection
-        close_conn = False  # Ne pas fermer la connection si elle est fournie
+        close_conn = False  # Don't close connection if provided
     else:
         conn = sqlite3.connect(db_name)
-        close_conn = True  # Fermer la connection si elle est créée ici
+        close_conn = True  # Close connection if created here
 
     try:
         c = conn.cursor()
@@ -39,11 +39,11 @@ def init_db(db_name: str, connection: Optional[sqlite3.Connection] = None) -> No
             else:
                 logger.error(f"[INIT DB] Migration script not found: {migration_script}")
     finally:
-        if close_conn and conn:  # Fermez la connection seulement si elle a été ouverte ici
+        if close_conn and conn:  # Close connection only if it was opened here
             conn.close()
 
 
-# Nom du fichier de la DB par défaut
+# Default DB file name
 DB_FILE_NAME = "pubsub.db"
 # --- FIN MODIFICATION POUR LA GESTION DE LA DB ET LES TESTS ---
 
@@ -52,13 +52,13 @@ def init_db(db_name: str, connection: Optional[sqlite3.Connection] = None) -> No
 app.config["SECRET_KEY"] = "secret!"
 socketio = SocketIO(app, cors_allowed_origins="*", async_mode="eventlet")
 
-# Initialisez la base de données réelle lors du démarrage de l'application
+# Initialize the real database when starting the application
 if __name__ == "__main__":
     init_db(DB_FILE_NAME)
 
 
 class Broker:
-    # Le broker peut recevoir une connection existante pour les tests
+    # The broker can receive an existing connection for tests
     def __init__(self, db_name: str, test_conn: Optional[sqlite3.Connection] = None):
         """
         Initialize the Broker with a database name.
@@ -67,17 +67,17 @@ def __init__(self, db_name: str, test_conn: Optional[sqlite3.Connection] = None)
         :param test_conn: An optional existing SQLite connection for testing purposes.
         """
         self.db_name = db_name
-        self._test_conn = test_conn  # Stocke la connection de test
+        self._test_conn = test_conn  # Store test connection
 
     def _get_db_connection(self) -> sqlite3.Connection:
         """Helper to get a database connection. Uses test_conn if available."""
         if self._test_conn:
-            return self._test_conn  # Retourne la connection de test
+            return self._test_conn  # Return test connection
         return sqlite3.connect(self.db_name)
 
     def _close_db_connection(self, conn: sqlite3.Connection) -> None:
         """Helper to close a database connection, if it's not a test connection."""
-        if conn != self._test_conn:  # Ne ferme pas la connection de test
+        if conn != self._test_conn:  # Don't close test connection
             conn.close()
 
     def register_subscription(self, sid: str, consumer: str, topic: str) -> None:
@@ -105,7 +105,7 @@ def register_subscription(self, sid: str, consumer: str, topic: str) -> None:
                 conn.rollback()  # Rollback on error
         finally:
             if conn:
-                self._close_db_connection(conn)  # Utilisez la nouvelle méthode de fermeture
+                self._close_db_connection(conn)  # Use the new close method
 
     def unregister_client(self, sid: str) -> None:
         conn = None
@@ -272,9 +272,9 @@ def get_consumptions(self) -> List[Dict[str, Any]]:
                 self._close_db_connection(conn)
 
 
-# Créez l'instance du Broker avec le nom du fichier de base de données réel
-# Cette ligne est exécutée uniquement si __name__ == "__main__"
-# Pour les tests, le Broker est instancié via la fixture
+# Create the Broker instance with the real database filename
+# This line is executed only if __name__ == "__main__"
+# For tests, the Broker is instantiated via the fixture
 broker = Broker(DB_FILE_NAME)
 
 
@@ -291,7 +291,7 @@ def publish() -> Tuple[Dict[str, str], int]:
         return jsonify({"status": "error", "message": "Missing topic, message_id, message, or producer"}), 400
 
     logger.info(f"Publishing message {message_id} to topic {topic} by {producer}")
-    # Le broker réel sera utilisé ici, pas le mock
+    # The real broker will be used here, not the mock
     broker.save_message(topic=topic, message_id=message_id, message=message, producer=producer)
 
     payload = {"topic": topic, "message_id": message_id, "message": message, "producer": producer}
@@ -375,10 +375,10 @@ def handle_consumed(data: Dict[str, Any]) -> None:
 
 
 @socketio.on("disconnect")
-def handle_disconnect() -> None:  # <-- Signature sans argument explicit pour le SID
+def handle_disconnect() -> None:  # <-- Signature without explicit argument for the SID
     """Handle client disconnection."""
     # noinspection PyUnresolvedReferences
-    sid = request.sid  # Toujours récupérer le SID via request.sid
+    sid = request.sid  # Always get SID via request.sid
     logger.info(f"Client disconnected (SID: {sid})")
     broker.unregister_client(sid)
 

tests/test_pubsub_client.py

@@ -13,27 +13,27 @@
 from client import BASE_URL, PubSubClient  # noqa: E402
 
 
-# Mock du socketio.Client
-# On va mocker la class socketio.Client elle-même, pas son instance directement
-# Ensuite, on accède à mock_sio_client.return_value pour mocker les méthodes de l'instance
+# Mock of socketio.Client
+# We will mock the socketio.Client class itself, not its instance directly
+# Then, we access mock_sio_client.return_value to mock the instance methods
 @pytest.fixture
 def mock_sio_client():
-    """Mocke l'instance de socketio.Client utilisée par PubSubClient."""
+    """Mocks the socketio.Client instance used by PubSubClient."""
     with patch("client.socketio.Client") as MockClient:  # <-- Patch la class directement dans le module client
-        instance = MockClient.return_value  # Ceci est le mock de l'instance qui sera créée
-        instance.connected = False  # Simule l'état initial déconnecté
-        yield MockClient  # On yield le Mock de la CLASS Client elle-même, pas son instance
+        instance = MockClient.return_value  # This is the mock of the instance that will be created
+        instance.connected = False  # Simulate initial disconnected state
+        yield MockClient  # We yield the Mock of the Client CLASS itself, not its instance
 
 
 # Mock de requests.post
 @pytest.fixture
 def mock_requests_post():
     """Mocke requests.post pour les appels de publication HTTP."""
-    # Patch requests.post dans le module client où il est utilisé
+    # Patch requests.post in the client module where it is used
     with patch("client.requests.post") as mock_post:  # <-- Patch requests.post dans le module client
         mock_response = MagicMock()
         mock_response.json.return_value = {"status": "ok", "message_id": "test_id_returned"}
-        mock_response.raise_for_status.return_value = None  # Pas d'erreurs HTTP par défaut
+        mock_response.raise_for_status.return_value = None  # No HTTP errors by default
         mock_post.return_value = mock_response
         yield mock_post
 
@@ -42,18 +42,18 @@ def mock_requests_post():
 
 
 def test_pubsub_client_init(mock_sio_client):
-    """Vérifie l'initialisation du client et l'enregistrement des gestionnaires."""
+    """Verifies client initialization and handler registration."""
     consumer = "test_alice"
     topics = ["sport", "finance"]
     client = PubSubClient(consumer, topics)
 
     assert client.consumer_name == consumer
     assert client.topics == topics
 
-    # Vérifiez que socketio.Client a été appelé une fois avec le bon argument
+    # Verify that socketio.Client was called once with the correct argument
     mock_sio_client.assert_called_once_with(reconnection=True)
 
-    # Vérifiez que les gestionnaires d'événements sont enregistrés sur l'instance mockée
+    # Verify that event handlers are registered on the mocked instance
     mock_sio_client.return_value.on.assert_any_call("message", client.on_message)
     mock_sio_client.return_value.on.assert_any_call("new_client", client.on_new_client)
     mock_sio_client.return_value.on.assert_any_call("client_disconnected", client.on_client_disconnected)
@@ -62,26 +62,26 @@ def test_pubsub_client_init(mock_sio_client):
 
 
 def test_pubsub_client_connect_success(mock_sio_client):
-    """Teste la méthode connect en cas de succès."""
+    """Tests the connect method in case of success."""
     consumer = "test_bob"
     topics = ["tech"]
     client = PubSubClient(consumer, topics)
 
-    # Obtenez le mock de l'instance client qui a été créée
+    # Get the mock of the client instance that was created
     mock_instance = mock_sio_client.return_value
-    mock_instance.connected = True  # Simule une connection réussie
+    mock_instance.connected = True  # Simulate successful connection
 
     client.connect()
 
-    # Vérifiez que connect a été appelé sur l'instance mockée avec la bonne URL
+    # Verify that connect was called on the mocked instance with the correct URL
     mock_instance.connect.assert_called_once_with(BASE_URL)
 
-    # Vérifiez que l'événement "subscribe" a été émis sur l'instance mockée
+    # Verify that the "subscribe" event was emitted on the mocked instance
     mock_instance.emit.assert_called_once_with("subscribe", {"consumer": consumer, "topics": topics})
 
 
 def test_pubsub_client_connect_failure(mock_sio_client, caplog):
-    """Teste la méthode connect en cas d'échec de connection."""
+    """Tests the connect method in case of connection failure."""
     consumer = "test_charlie"
     topics = ["music"]
     client = PubSubClient(consumer, topics)
@@ -94,9 +94,9 @@ def test_pubsub_client_connect_failure(mock_sio_client, caplog):
     with caplog.at_level(logging.ERROR):  # Capture les logs d'erreur
         client.connect()
 
-    # Le message d'erreur doit être dans les logs
+    # The error message should be in the logs
     assert "Failed to connect to server: Connection refused" in caplog.text
-    # Vérifiez que connect a été appelé même s'il a levé une exception
+    # Verify that connect was called even if it raised an exception
     mock_instance.connect.assert_called_once()
 
 
@@ -113,7 +113,7 @@ def test_pubsub_client_on_message(caplog):
 
 
 def test_pubsub_client_publish(mock_requests_post):
-    """Teste la méthode publish."""
+    """Tests the publish method."""
     consumer = "test_eve"
     topics = ["travel"]
     client = PubSubClient(consumer, topics)
@@ -124,7 +124,7 @@ def test_pubsub_client_publish(mock_requests_post):
 
     response = client.publish(topic_to_publish, message_content, message_id)
 
-    # Vérifiez que requests.post a été appelé avec les bonnes données
+    # Verify that requests.post was called with the correct data
     expected_url = f"{BASE_URL}/publish"
     expected_json = {
         "topic": topic_to_publish,
@@ -134,41 +134,41 @@ def test_pubsub_client_publish(mock_requests_post):
     }
     mock_requests_post.assert_called_once_with(expected_url, json=expected_json)
 
-    # Vérifiez la réponse renvoyée par la méthode publish
+    # Verify the response returned by the publish method
     assert response == {"status": "ok", "message_id": "test_id_returned"}
 
 
 def test_pubsub_client_disconnect_connected(mock_sio_client, caplog):
-    """Teste la déconnection quand le client est connecté."""
+    """Tests disconnection when the client is connected."""
     consumer = "test_frank"
     topics = ["sports"]
     client = PubSubClient(consumer, topics)
 
     # Obtenez le mock de l'instance client
     mock_instance = mock_sio_client.return_value
-    mock_instance.connected = True  # Simule un état connecté
+    mock_instance.connected = True  # Simulate connected state
 
     with caplog.at_level(logging.INFO):
         client.disconnect()
 
-    # Vérifiez que disconnect a été appelé sur l'instance mockée
+    # Verify that disconnect was called on the mocked instance
     mock_instance.disconnect.assert_called_once()
     assert f"Disconnected {consumer} from server." in caplog.text
 
 
 def test_pubsub_client_disconnect_not_connected(mock_sio_client, caplog):
-    """Teste la déconnection quand le client n'est pas connecté."""
+    """Tests disconnection when the client is not connected."""
     consumer = "test_grace"
     topics = ["art"]
     client = PubSubClient(consumer, topics)
 
     # Obtenez le mock de l'instance client
     mock_instance = mock_sio_client.return_value
-    mock_instance.connected = False  # Simule un état non connecté
+    mock_instance.connected = False  # Simulate disconnected state
 
     with caplog.at_level(logging.INFO):
         client.disconnect()
 
-    # Vérifiez que disconnect n'a PAS été appelé sur l'instance mockée
+    # Verify that disconnect was NOT called on the mocked instance
     mock_instance.disconnect.assert_not_called()
     assert f"Disconnected {consumer} from server." not in caplog.text