charging station: add tests to distinguish valid value in enumeration

Author: blemoineovh

analysers/analyser_merge_charging_station_FR.py

@@ -34,6 +34,7 @@
 
 
 class Analyser_Merge_Charging_station_FR(Analyser_Merge_Point):
+    MAX_POWER_KW = 401
     WIKIDATA_MAP = {
         "ionity": "Q42717773",
         "bouygues": "Q3046208",
@@ -45,43 +46,111 @@ class Analyser_Merge_Charging_station_FR(Analyser_Merge_Point):
         "Izivia": "Q86671322",
     }
 
-    def keepMaxValueIfEnum(str):
+    @staticmethod
+    def keepMaxValueIfEnum(str_val):
+        # Constante pour limiter les valeurs aberrantes (en kW)
+        MAX_POWER_KW = 500
+
         # si la valeur contient un ; on sépare et on prend la plus haute valeur
-        if ";" in str:
-            boom = str.split(";")
-            max = 0
+        if ";" in str_val:
+            boom = str_val.split(";")
+            max_val = 0
             for p in boom:
-                p = int(p)
-                if p > max:
-                    max = p
-
-            if max > 0:
-                str = max
-        return str
-
-    def getPuissanceNominaleInKw(self, puissance_nominale):
-        # deviner un nombre en kw dans la puissance nominale,
-        # les valeurs de plus de 401 sont à diviser par mille,
-        # il faut aussi évacuer le leftpad de 0
-        if puissance_nominale is None:
+                # Supprimer les unités éventuelles (comme "kw")
+                p_clean = p.lower().replace("kw", "").strip()
+                try:
+                    p_val = int(float(p_clean))
+                    # Ignorer les valeurs supérieures à la limite maximale connue (MAX_POWER_KW)
+                    if (
+                        p_val <= Analyser_Merge_Charging_station_FR.MAX_POWER_KW
+                        and p_val > max_val
+                    ):
+                        max_val = p_val
+                except ValueError:
+                    # Ignorer les valeurs qui ne peuvent pas être converties en nombre
+                    pass
+
+            if max_val > 0:
+                str_val = str(max_val)
+        else:
+            # Gérer les cas où il n'y a pas de délimiteur mais une unité est présente
+            if "kw" in str_val.lower():
+                p_clean = str_val.lower().replace("kw", "").strip()
+                try:
+                    p_val = int(float(p_clean))
+                    if p_val <= Analyser_Merge_Charging_station_FR.MAX_POWER_KW:
+                        str_val = str(p_val)
+                except ValueError:
+                    pass
+        return str_val
+
+    def _normalize_number(self, v: float) -> str:
+        """Formate un float en supprimant les .0 inutiles et les zéros de fin."""
+        try:
+            iv = int(v)
+            if abs(v - iv) < 1e-9:
+                return str(iv)
+            return f"{v:.6f}".rstrip("0").rstrip(".")
+        except Exception:
+            return str(v)
+
+    def getPuissanceNominaleInKw(self, raw):
+        """
+        Calcule la puissance nominale en kW à partir d'une valeur brute.
+
+        Règles:
+        - Si 'raw' est une énumération 'a;b;c', on garde la valeur max en kW <= MAX_POWER_KW.
+        - Si 'raw' est une valeur unique:
+            * suffixe 'kW' => valeur déjà en kW
+            * suffixe 'W'  => conversion W -> kW
+            * sans unité:
+                - si > MAX_POWER_KW => on suppose des watts, on divise par 1000
+                - sinon => déjà en kW
+
+        Retour: 'X kW' ou None si indéterminable.
+        """
+        if raw is None:
             return None
-        puissance_nominale = str(puissance_nominale)
 
-        if puissance_nominale is None:
+        s = str(raw).strip()
+        if s == "":
+            return None
+
+        max_kw = getattr(self, "MAX_POWER_KW", 500)
+
+        # Cas énumération: on délègue à keepMaxValueIfEnum puis on formate.
+        if ";" in s:
+            max_str = self.keepMaxValueIfEnum(s)
+            if not max_str:
+                return None
+            try:
+                v = float(
+                    str(max_str).replace(",", ".").lower().replace("kw", "").strip()
+                )
+            except Exception:
+                return None
+            return f"{self._normalize_number(v)} kW"
+
+        # Cas valeur unique
+        s_norm = s.lower().replace(",", ".")
+        try:
+            if s_norm.endswith("kw"):
+                v = float(s_norm[:-2].strip())
+                return f"{self._normalize_number(v)} kW"
+
+            if s_norm.endswith("w"):
+                v_w = float(s_norm[:-1].strip())
+                v = v_w / 1000.0
+                return f"{self._normalize_number(v)} kW"
+
+            # Sans unité
+            v = float(s_norm)
+            if v > max_kw:
+                # On suppose des watts => conversion en kW
+                v = v / 1000.0
+            return f"{self._normalize_number(v)} kW"
+        except Exception:
             return None
-        # Convertir en chaîne et supprimer les zéros à gauche
-        puissance_str = str(puissance_nominale).lstrip("0")
-        if not puissance_str:
-            return 0
-
-        puissance_str = self.keepMaxValueIfEnum(puissance_str)
-        # Reconvertir en entier
-        puissance_nominale = int(puissance_str)
-        # puisssance max de borne en kW connue
-        if puissance_nominale > 401:
-            return str(puissance_nominale / 1000) + " kW"
-        else:
-            return str(puissance_nominale) + " kW"
 
     def __init__(self, config, logger=None):
         Analyser_Merge_Point.__init__(self, config, logger)
@@ -109,23 +178,23 @@ def __init__(self, config, logger=None):
             level=3,
             tags=["merge", "fix:imagery", "fix:survey", "fix:picture"],
             title=T_("Car charging station not integrated"),
-            **doc
+            **doc,
         )
         self.def_class_possible_merge(
             item=8411,
             id=3,
             level=3,
             tags=["merge", "fix:imagery", "fix:survey", "fix:picture"],
             title=T_("Car charging station, integration suggestion"),
-            **doc
+            **doc,
         )
         self.def_class_update_official(
             item=8412,
             id=4,
             level=3,
             tags=["merge", "fix:imagery", "fix:survey", "fix:picture"],
             title=T_("Car charging station update"),
-            **doc
+            **doc,
         )
 
         self.init(

tests/test_analyser_merge_charging_station_FR.py

@@ -0,0 +1,90 @@
+# !/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import unittest
+from analysers.analyser_merge_charging_station_FR import (
+    Analyser_Merge_Charging_station_FR,
+)
+
+
+class TestAnalyserMergeChargingStationFR(unittest.TestCase):
+
+    def test_keepMaxValueIfEnum(self):
+        # Test de base avec une liste de valeurs sans unité
+        self.assertEqual(
+            "20", Analyser_Merge_Charging_station_FR.keepMaxValueIfEnum("15;20;11.5")
+        )
+
+        # Test avec valeurs dépassant la limite maximale connue (MAX_POWER_KW)
+        self.assertEqual(
+            "20",
+            Analyser_Merge_Charging_station_FR.keepMaxValueIfEnum("15;20;1200;11.5"),
+        )
+
+        # Test avec des unités mélangées
+        self.assertEqual(
+            "20", Analyser_Merge_Charging_station_FR.keepMaxValueIfEnum("15;20kw;11.5")
+        )
+
+        # Test avec une seule valeur
+        self.assertEqual(
+            "30", Analyser_Merge_Charging_station_FR.keepMaxValueIfEnum("30")
+        )
+
+        # Test avec des zéros au début
+        self.assertEqual(
+            "50", Analyser_Merge_Charging_station_FR.keepMaxValueIfEnum("050;30;40")
+        )
+
+    def test_getPuissanceNominaleInKw(self):
+        # Créer une instance sans l'initialiser complètement
+        analyser = Analyser_Merge_Charging_station_FR.__new__(
+            Analyser_Merge_Charging_station_FR
+        )
+
+        # Définir seulement les attributs nécessaires pour la méthode testée
+        analyser.MAX_POWER_KW = 401
+
+        # Définir la méthode _normalize_number manuellement
+        def _normalize_number(v):
+            try:
+                iv = int(v)
+                if abs(v - iv) < 1e-9:
+                    return str(iv)
+                return f"{v:.6f}".rstrip("0").rstrip(".")
+            except Exception:
+                return str(v)
+
+        analyser._normalize_number = _normalize_number
+
+        # Attacher la méthode keepMaxValueIfEnum à l'instance
+        analyser.keepMaxValueIfEnum = (
+            Analyser_Merge_Charging_station_FR.keepMaxValueIfEnum
+        )
+
+        # Test avec une énumération et un max dépassant MAX_POWER_KW (doit ignorer 1200)
+        self.assertEqual(
+            "20 kW", analyser.getPuissanceNominaleInKw("15;20kw;1200;11.5")
+        )
+
+        # Test avec une énumération en dessous de MAX_POWER_KW
+        self.assertEqual("50 kW", analyser.getPuissanceNominaleInKw("30;50;20"))
+
+        # Test avec une valeur unique valide
+        self.assertEqual("30 kW", analyser.getPuissanceNominaleInKw("30"))
+
+        # Test avec None
+        self.assertIsNone(analyser.getPuissanceNominaleInKw(None))
+
+        # Test avec une valeur à 0
+        self.assertEqual("0 kW", analyser.getPuissanceNominaleInKw("0"))
+
+        # Test avec une valeur au-dessus de la limite avec conversion automatique
+        self.assertEqual("350 kW", analyser.getPuissanceNominaleInKw("350000"))
+
+        # Test daube
+        self.assertEqual(None, analyser.getPuissanceNominaleInKw("daube"))
+
+
+if __name__ == "__main__":
+    unittest.main()