chore: fix bug

backend/gestion/services/adresses_correction.go

@@ -81,8 +81,24 @@ func (acs *AddressCorrectionService) ResolveAddress(rawAddress string) (*Address
 		return nil, fmt.Errorf("adresse vide")
 	}
 
-	// ── Étape 1 : essai exact via GeoService (utilise le cache Redis) ──
-	if loc, err := acs.geoService.GeocodeAddress(rawAddress); err == nil {
+	// ── Étape 1 : essai exact (cache Redis puis Nominatim direct) ──
+	// Volontairement pas d'appel à acs.geoService.GeocodeAddress ici : cette
+	// méthode retombe elle-même sur ResolveAddress quand le géocodage direct
+	// échoue, ce qui provoquerait une récursion infinie GeocodeAddress <->
+	// ResolveAddress pour toute adresse nécessitant réellement une
+	// correction (le cas d'usage même de cette fonction).
+	if loc, err := acs.geoService.getFromCache(rawAddress); err == nil {
+		return &AddressSuggestion{
+			OriginalAddress:   rawAddress,
+			CorrectedAddress:  rawAddress,
+			Coordinates:       Coordinates{Latitude: loc.Latitude, Longitude: loc.Longitude},
+			Confidence:        1.0,
+			CorrectionApplied: false,
+			Source:            "exact",
+		}, nil
+	}
+	if loc, err := acs.geoService.fetchFromNominatim(rawAddress); err == nil {
+		acs.geoService.saveToCache(rawAddress, loc)
 		return &AddressSuggestion{
 			OriginalAddress:   rawAddress,
 			CorrectedAddress:  rawAddress,

backend/gestion/services/adresses_correction_test.go

@@ -0,0 +1,291 @@
+package services
+
+import "testing"
+
+// Ces tests couvrent la partie pure de l'algorithme de correction d'adresse
+// (normalisation, décomposition, score de confiance) — sans appel réseau à
+// Nominatim (rate-limité à 1 req/s, non adapté à une suite de tests). Les
+// méthodes qui interrogent Nominatim (nominatimFuzzySearch, structuredSearch,
+// ResolveAddress) ne sont donc pas exercées ici.
+
+func TestNormalize_RemovesAccentsAndNormalizesSpacing(t *testing.T) {
+	cases := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{"accent simple", "Crébillon", "Crebillon"},
+		{"plusieurs accents", "Cours des 50 Otages à Nantes", "Cours des 50 Otages a Nantes"},
+		{"espaces multiples", "12   Rue  de   Verdun", "12 Rue de Verdun"},
+		{"déjà normalisé", "Rue de Verdun", "Rue de Verdun"},
+		{"cédille", "Façade", "Facade"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := normalize(c.input); got != c.want {
+				t.Errorf("normalize(%q) = %q, want %q", c.input, got, c.want)
+			}
+		})
+	}
+}
+
+// Les abréviations ne sont reconnues qu'avec leur point final (sauf "Rte ")
+// — une adresse mal écrite sans point ne sera pas développée. Ce test
+// documente ce comportement réel plutôt que de le supposer.
+func TestExpandFrenchAbbreviations(t *testing.T) {
+	cases := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{"Av. développé", "12 Av. de la Paix", "12 Avenue de la Paix"},
+		{"Bd. développé", "5 Bd. Jean Moulin", "5 Boulevard Jean Moulin"},
+		{"Rte avec espace développé", "Rte de Vannes", "Route de Vannes"},
+		{"Pl. développé", "3 Pl. Royale", "3 Place Royale"},
+		{"Bd sans point NON développé (limite connue)", "5 Bd Jean Moulin", "5 Bd Jean Moulin"},
+		{"pas d'abréviation", "12 Rue Crébillon", "12 Rue Crébillon"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := expandFrenchAbbreviations(c.input); got != c.want {
+				t.Errorf("expandFrenchAbbreviations(%q) = %q, want %q", c.input, got, c.want)
+			}
+		})
+	}
+}
+
+// Exemple tiré du commentaire du code source lui-même : une particule ("le")
+// insérée dans un nom de rue peut faire échouer un géocodage exact.
+func TestSimplifyStreetName_RemovesEmbeddedArticles(t *testing.T) {
+	input := "20 Rue Gabriel le Pan de Ligny"
+	want := "20 Rue Gabriel Pan Ligny"
+	if got := simplifyStreetName(input); got != want {
+		t.Errorf("simplifyStreetName(%q) = %q, want %q", input, got, want)
+	}
+}
+
+func TestSimplifyStreetName_LeavesShortAddressesUnchanged(t *testing.T) {
+	// La garde ne s'applique qu'en dessous de 5 mots ("3 Rue de la Paix" en
+	// fait exactement 5 et serait donc simplifiée, voir le test ci-dessus).
+	input := "3 Rue Crébillon"
+	if got := simplifyStreetName(input); got != input {
+		t.Errorf("simplifyStreetName ne doit pas modifier une adresse de moins de 5 mots: got=%q want=%q", got, input)
+	}
+}
+
+// Décomposition d'adresses de Nantes (44000), y compris des cas mal écrits :
+// ville en minuscule (non détectée par l'heuristique de majuscule), code
+// postal mal saisi (lettre au lieu d'un zéro).
+func TestParseAddressParts_HandlesRealisticAndBadlyWrittenNantesAddresses(t *testing.T) {
+	cases := []struct {
+		name         string
+		input        string
+		wantNumber   string
+		wantStreet   string
+		wantPostcode string
+		wantCity     string
+	}{
+		{
+			name:         "adresse bien formée",
+			input:        "12 Rue Crébillon 44000 Nantes",
+			wantNumber:   "12",
+			wantStreet:   "Rue Crébillon",
+			wantPostcode: "44000",
+			wantCity:     "Nantes",
+		},
+		{
+			name:         "ville en minuscule non détectée (limite connue)",
+			input:        "3 place royale 44000 nantes",
+			wantNumber:   "3",
+			wantStreet:   "place royale nantes", // la ville minuscule reste fondue dans la rue
+			wantPostcode: "44000",
+			wantCity:     "",
+		},
+		{
+			name:         "code postal mal saisi (lettre O au lieu de zéro) non reconnu",
+			input:        "8 Rue de Verdun 44OOO Nantes",
+			wantNumber:   "8",
+			wantStreet:   "Rue de Verdun 44OOO", // "44OOO" n'est pas un code postal valide, reste dans la rue
+			wantPostcode: "",
+			wantCity:     "Nantes",
+		},
+		{
+			name:         "particule intégrée au nom de rue",
+			input:        "20 Rue Gabriel le Pan de Ligny 44000 Nantes",
+			wantNumber:   "20",
+			wantStreet:   "Rue Gabriel le Pan de Ligny",
+			wantPostcode: "44000",
+			wantCity:     "Nantes",
+		},
+		{
+			name:         "sans numéro de rue",
+			input:        "Rue Crébillon 44000 Nantes",
+			wantNumber:   "",
+			wantStreet:   "Rue Crébillon",
+			wantPostcode: "44000",
+			wantCity:     "Nantes",
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := parseAddressParts(c.input)
+			if got.streetNumber != c.wantNumber {
+				t.Errorf("streetNumber = %q, want %q", got.streetNumber, c.wantNumber)
+			}
+			if got.streetName != c.wantStreet {
+				t.Errorf("streetName = %q, want %q", got.streetName, c.wantStreet)
+			}
+			if got.postcode != c.wantPostcode {
+				t.Errorf("postcode = %q, want %q", got.postcode, c.wantPostcode)
+			}
+			if got.city != c.wantCity {
+				t.Errorf("city = %q, want %q", got.city, c.wantCity)
+			}
+		})
+	}
+}
+
+func TestIsPostcode(t *testing.T) {
+	cases := []struct {
+		input string
+		want  bool
+	}{
+		{"44000", true},
+		{"44100", true},
+		{"44OOO", false},  // lettre O au lieu de zéro — typo réaliste
+		{"4400", false},   // trop court
+		{"440000", false}, // trop long
+		{"", false},
+		{"abcde", false},
+	}
+	for _, c := range cases {
+		if got := isPostcode(c.input); got != c.want {
+			t.Errorf("isPostcode(%q) = %v, want %v", c.input, got, c.want)
+		}
+	}
+}
+
+func TestIsNumeric(t *testing.T) {
+	cases := []struct {
+		input string
+		want  bool
+	}{
+		{"12", true},
+		{"0", true},
+		{"", false},
+		{"12b", false},
+		{"-1", false},
+	}
+	for _, c := range cases {
+		if got := isNumeric(c.input); got != c.want {
+			t.Errorf("isNumeric(%q) = %v, want %v", c.input, got, c.want)
+		}
+	}
+}
+
+// La distance de Levenshtein doit rester tolérante aux fautes de frappe
+// courantes (lettre manquante, inversion) et normalize() doit annuler l'écart
+// dû aux accents.
+func TestLevenshteinRatio_TypoTolerance(t *testing.T) {
+	cases := []struct {
+		name    string
+		a, b    string
+		minWant float64
+	}{
+		{"faute de frappe simple (Nantse/Nantes)", "Nantse", "Nantes", 0.6},
+		{"lettre manquante (Verdun/Verdu)", "Verdu", "Verdun", 0.7},
+		{"identique", "Nantes", "Nantes", 1.0},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := levenshteinRatio(c.a, c.b); got < c.minWant {
+				t.Errorf("levenshteinRatio(%q, %q) = %.2f, want >= %.2f", c.a, c.b, got, c.minWant)
+			}
+		})
+	}
+}
+
+func TestLevenshteinRatio_AccentDifferenceResolvedByNormalize(t *testing.T) {
+	a, b := "Crebillon", "Crébillon"
+	if levenshteinRatio(a, b) >= 1.0 {
+		t.Fatalf("précondition: %q et %q ne devraient pas être identiques sans normalisation", a, b)
+	}
+	if got := levenshteinRatio(normalize(a), normalize(b)); got != 1.0 {
+		t.Errorf("après normalize(), les deux formes doivent être identiques: ratio=%.2f", got)
+	}
+}
+
+// Le score de confiance doit favoriser nettement une suggestion proche de
+// l'adresse saisie (même mal orthographiée) par rapport à une suggestion
+// sans rapport.
+func TestComputeConfidence_ScoresCloseMatchHigherThanUnrelated(t *testing.T) {
+	original := "12 Rue Crebillon 44000 Nantse" // fautes: pas d'accent + "Nantse"
+	closeMatch := "12 Rue Crébillon, 44000, Nantes"
+	unrelated := "1 Avenue des Champs-Élysées, 75008, Paris"
+
+	closeScore := computeConfidence(original, closeMatch, 0.5)
+	unrelatedScore := computeConfidence(original, unrelated, 0.5)
+
+	if closeScore <= unrelatedScore {
+		t.Errorf("score adresse proche (%.2f) devrait être supérieur au score adresse sans rapport (%.2f)", closeScore, unrelatedScore)
+	}
+	if closeScore < 0.40 {
+		t.Errorf("score adresse proche trop bas pour dépasser le seuil d'acceptation (0.40): got=%.2f", closeScore)
+	}
+}
+
+// buildAddressVariants doit inclure la forme sans accent et la forme avec
+// abréviation développée pour une adresse mal écrite combinant les deux.
+func TestBuildAddressVariants_IncludesNormalizedAndExpandedForms(t *testing.T) {
+	input := "12 Av. de la Paix 44000 Nantes" // abréviation, pas d'accent ici mais le principe se généralise
+	variants := buildAddressVariants(input)
+
+	if len(variants) < 2 {
+		t.Fatalf("attendu plusieurs variantes, got=%d: %v", len(variants), variants)
+	}
+	if variants[0] != input {
+		t.Errorf("la première variante doit être l'adresse originale: got=%q", variants[0])
+	}
+
+	foundExpanded := false
+	for _, v := range variants {
+		if v == "12 Avenue de la Paix 44000 Nantes" {
+			foundExpanded = true
+		}
+	}
+	if !foundExpanded {
+		t.Errorf("attendu une variante avec l'abréviation développée parmi: %v", variants)
+	}
+
+	// Pas de doublons.
+	seen := map[string]bool{}
+	for _, v := range variants {
+		if seen[v] {
+			t.Errorf("variante en double: %q dans %v", v, variants)
+		}
+		seen[v] = true
+	}
+}
+
+func TestFormatNominatimAddress_PrefersStructuredFieldsOverDisplayName(t *testing.T) {
+	s := NominatimSuggestion{
+		DisplayName: "12, Rue Crébillon, Nantes, Loire-Atlantique, France métropolitaine, France",
+	}
+	s.Address.HouseNumber = "12"
+	s.Address.Road = "Rue Crébillon"
+	s.Address.Postcode = "44000"
+	s.Address.City = "Nantes"
+
+	want := "12 Rue Crébillon, 44000, Nantes"
+	if got := formatNominatimAddress(s); got != want {
+		t.Errorf("formatNominatimAddress = %q, want %q", got, want)
+	}
+}
+
+func TestFormatNominatimAddress_FallsBackToDisplayNameWhenNoStructuredFields(t *testing.T) {
+	s := NominatimSuggestion{DisplayName: "Quelque part en France"}
+	if got := formatNominatimAddress(s); got != s.DisplayName {
+		t.Errorf("formatNominatimAddress sans champs structurés doit renvoyer DisplayName: got=%q want=%q", got, s.DisplayName)
+	}
+}

backend/gestion/services/geo_services_test.go

@@ -0,0 +1,142 @@
+package services
+
+import (
+	"math"
+	"testing"
+)
+
+// Repères réels de Nantes (44000) utilisés pour vérifier le calcul de
+// distance/temps de trajet des commandes.
+var (
+	placeRoyale    = Coordinates{Latitude: 47.2148, Longitude: -1.5584}
+	gareNantes     = Coordinates{Latitude: 47.2173, Longitude: -1.5426}
+	aeroportNantes = Coordinates{Latitude: 47.1532, Longitude: -1.6107}
+)
+
+func almostEqual(a, b, tolerance float64) bool {
+	return math.Abs(a-b) <= tolerance
+}
+
+func TestCalculateDistance_SamePointIsZero(t *testing.T) {
+	if got := CalculateDistance(placeRoyale, placeRoyale); got != 0 {
+		t.Errorf("distance entre un point et lui-même: got=%.4f want=0", got)
+	}
+}
+
+// Le long d'un même méridien (même longitude), la distance Haversine est
+// exacte : 1° de latitude = R * (π/180) ≈ 111.19 km.
+func TestCalculateDistance_OneDegreeLatitudeIsExact(t *testing.T) {
+	from := Coordinates{Latitude: 47.0, Longitude: -1.5536}
+	to := Coordinates{Latitude: 48.0, Longitude: -1.5536}
+	want := EarthRadiusKm * (math.Pi / 180.0)
+
+	got := CalculateDistance(from, to)
+	if !almostEqual(got, want, 0.01) {
+		t.Errorf("distance 1° de latitude: got=%.4f want=%.4f", got, want)
+	}
+}
+
+func TestCalculateDistance_IsSymmetric(t *testing.T) {
+	d1 := CalculateDistance(placeRoyale, gareNantes)
+	d2 := CalculateDistance(gareNantes, placeRoyale)
+	if !almostEqual(d1, d2, 0.0001) {
+		t.Errorf("la distance doit être symétrique: A->B=%.4f B->A=%.4f", d1, d2)
+	}
+}
+
+// Place Royale <-> Aéroport de Nantes : environ 8 km à vol d'oiseau.
+func TestCalculateDistance_RealNantesLandmarks(t *testing.T) {
+	got := CalculateDistance(placeRoyale, aeroportNantes)
+	if got < 6 || got > 10 {
+		t.Errorf("distance Place Royale -> Aéroport Nantes hors plage réaliste: got=%.2f km, want=[6,10]", got)
+	}
+}
+
+func TestCalculateETA_VeryCloseReturnsMinETA(t *testing.T) {
+	cases := []float64{0, 0.01, 0.05, 0.099}
+	for _, d := range cases {
+		if got := CalculateETA(d); got != MinETA {
+			t.Errorf("CalculateETA(%.3f km): got=%d want=%d (MinETA)", d, got, MinETA)
+		}
+	}
+}
+
+// Formule : (distance/25 km/h)*60 min, +20% de marge trafic, arrondi par troncature.
+func TestCalculateETA_MatchesFormulaForNormalDistance(t *testing.T) {
+	distanceKm := 10.0
+	travelTime := (distanceKm / 25.0) * 60.0
+	want := int(travelTime * 1.2)
+
+	got := CalculateETA(distanceKm)
+	if got != want {
+		t.Errorf("CalculateETA(%.1f km): got=%d want=%d", distanceKm, got, want)
+	}
+}
+
+func TestCalculateETA_VeryFarClampsToMaxETA(t *testing.T) {
+	if got := CalculateETA(1000); got != MaxETA {
+		t.Errorf("CalculateETA(1000 km): got=%d want=%d (MaxETA)", got, MaxETA)
+	}
+}
+
+// L'ETA ne doit jamais sortir de l'intervalle [MinETA, MaxETA], quelle que
+// soit la distance fournie (y compris des valeurs aberrantes).
+func TestCalculateETA_AlwaysWithinBounds(t *testing.T) {
+	distances := []float64{-5, 0, 0.05, 1, 5, 10, 50, 100, 500, 10000}
+	for _, d := range distances {
+		got := CalculateETA(d)
+		if got < MinETA || got > MaxETA {
+			t.Errorf("CalculateETA(%.2f): got=%d, hors bornes [%d,%d]", d, got, MinETA, MaxETA)
+		}
+	}
+}
+
+// Sans clé TomTom configurée (cas de cet environnement de test), le calcul
+// doit retomber sur Haversine + CalculateETA, sans appel réseau.
+func TestCalculateETAWithTomTom_FallsBackToHaversineWithoutAPIKey(t *testing.T) {
+	if len(tomTomKeys.keys) != 0 {
+		t.Skip("test valable uniquement sans clé TomTom configurée dans l'environnement")
+	}
+
+	wantDistance := CalculateDistance(placeRoyale, aeroportNantes)
+	wantETA := CalculateETA(wantDistance)
+
+	gotETA, gotDistance, err := CalculateETAWithTomTom(placeRoyale, aeroportNantes)
+	if err != nil {
+		t.Fatalf("CalculateETAWithTomTom (fallback): %v", err)
+	}
+	if gotDistance != wantDistance {
+		t.Errorf("distance fallback: got=%.4f want=%.4f", gotDistance, wantDistance)
+	}
+	if gotETA != wantETA {
+		t.Errorf("ETA fallback: got=%d want=%d", gotETA, wantETA)
+	}
+}
+
+func TestValidateCoordinates(t *testing.T) {
+	cases := []struct {
+		name    string
+		coords  Coordinates
+		wantErr bool
+	}{
+		{"Nantes valide", placeRoyale, false},
+		{"latitude limite haute valide", Coordinates{Latitude: 90, Longitude: 0}, false},
+		{"latitude limite basse valide", Coordinates{Latitude: -90, Longitude: 0}, false},
+		{"latitude trop haute", Coordinates{Latitude: 90.1, Longitude: 0}, true},
+		{"latitude trop basse", Coordinates{Latitude: -90.1, Longitude: 0}, true},
+		{"longitude limite haute valide", Coordinates{Latitude: 0, Longitude: 180}, false},
+		{"longitude trop haute", Coordinates{Latitude: 0, Longitude: 180.1}, true},
+		{"longitude trop basse", Coordinates{Latitude: 0, Longitude: -180.1}, true},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			err := ValidateCoordinates(c.coords)
+			if c.wantErr && err == nil {
+				t.Error("attendu une erreur, reçu nil")
+			}
+			if !c.wantErr && err != nil {
+				t.Errorf("erreur inattendue: %v", err)
+			}
+		})
+	}
+}