Premiere commit - Omika

2026-10-23 18:46:50 +02:00
commit 8ea76c1b24
2155 changed files with 984301 additions and 0 deletions
@@ -0,0 +1,495 @@
+using Omika.Core.Compatibility;
+using Omika.Core.Domain.Entities.Clients;
+using Omika.Core.Domain.ValueObjects;
+using Omika.Data.Mapping.Common;
+using BatikModels = Omika.Data.HfSql.Models.Batik;
+using OmikaModels = Omika.Data.HfSql.Models.Omika;
+using BatikMappers = Omika.Data.Mapping.Batik;
+using OmikaMappers = Omika.Data.Mapping.Omika;
+
+namespace Omika.Tests.Mapping;
+
+/// <summary>
+/// Tests unitaires des premiers mappers physiques → canonique (Clients,
+/// Adresses et valeurs de référentiel). Aucune base réelle, aucun HFSQL :
+/// uniquement des objets en mémoire.
+/// </summary>
+public class PhysicalToCanonicalMappingTests
+{
+    // ---- 1. Client Batik minimal -------------------------------------------------
+
+    [Fact]
+    public void ClientBatik_Minimal_MapsWithoutExceptionAndKeepsNoFabricatedValue()
+    {
+        var row = new BatikModels.ClientRow { CLPKID = 1 };
+
+        CanonicalMappingResult<Client> result = BatikMappers.BatikClientMapper.Map(row);
+
+        Assert.Equal(DatabaseSchemaVersion.Batik, result.SourceVersion);
+        Assert.NotNull(result.Value);
+        Assert.Null(result.Value.Nom);
+        Assert.Null(result.Value.Type);
+        Assert.Null(result.Value.Statut);
+        Assert.Null(result.Value.Coordonnees);
+        Assert.Null(result.Value.AdressePrincipale);
+        Assert.False(result.Value.EstArchive);
+        Assert.NotNull(result.Value.SourceReference);
+        Assert.Equal(1, result.Value.SourceReference!.NumericId);
+        Assert.Equal(DatabaseSchemaVersion.Batik, result.Value.SourceReference!.Source);
+        Assert.Null(result.Value.SourceReference!.EntityGuid);
+        Assert.Empty(result.Warnings);
+    }
+
+    // ---- 2. Client Batik complet -------------------------------------------------
+
+    [Fact]
+    public void ClientBatik_Full_MapsAllCanonicalProperties()
+    {
+        var row = new BatikModels.ClientRow
+        {
+            CLPKID = 42,
+            CLCodeClient = "C-001",
+            CLNom = "Ville de Lyon",
+            CLIDType = 2,
+            CLIDStatut = 3,
+            CLFormeJuridique = "Collectivité",
+            CLCodeTVA = "FR12345678901",
+            CLCodeComptable = "411LYON",
+            CLSIREN = "123456789",
+            CLSIRET = "12345678900012",
+            CLEmail = "contact@ville-lyon.fr",
+            CLTel = "0472000000",
+            CLFax = "0472000001",
+            CLPays = "FR",
+            CLInfoSup = "Client principal",
+            CLBlocage = true,
+            ClRaisonBlocage = "Litige en cours",
+            Archive = true,
+            CLIDAdressePrincipale = 10
+        };
+
+        var referenceRows = new Dictionary<long, BatikModels.ParametreMetierRow>
+        {
+            [2] = new() { PAPKID = 2, PACode = "T", PAValeur = "1", PALibelle = "Régie" },
+            [3] = new() { PAPKID = 3, PACode = "S", PAValeur = "1", PALibelle = "Actif" }
+        };
+
+        var adresses = new Dictionary<long, BatikModels.AdresseRow>
+        {
+            [10] = new() { ADPKID = 10, ADEtiquette = "Mairie", ADLigne1 = "1 place de la Comédie", ADVille = "Lyon", ADCodePostal = "69001" }
+        };
+
+        CanonicalMappingResult<Client> result = BatikMappers.BatikClientMapper.Map(row, referenceRows, adresses);
+
+        Client client = result.Value;
+        Assert.Equal("C-001", client.Code);
+        Assert.Equal("Ville de Lyon", client.Nom);
+        Assert.Equal("Régie", client.Type!.Label);
+        Assert.Equal(2, client.Type!.LegacyId);
+        Assert.Equal("T", client.Type!.Code);
+        Assert.Equal("Actif", client.Statut!.Label);
+        Assert.Equal(3, client.Statut!.LegacyId);
+        Assert.Equal("Collectivité", client.FormeJuridique!.Label);
+        Assert.Equal("FR12345678901", client.CodeTva);
+        Assert.Equal("411LYON", client.CodeComptable);
+        Assert.Equal("123456789", client.Siren);
+        Assert.Equal("12345678900012", client.Siret);
+        Assert.Equal("contact@ville-lyon.fr", client.Coordonnees!.Email);
+        Assert.Equal("0472000000", client.Coordonnees!.Phone);
+        Assert.Equal("0472000001", client.Coordonnees!.Fax);
+        Assert.Equal("FR", client.Pays);
+        Assert.Equal("Client principal", client.InformationsComplementaires);
+        Assert.True(client.EstBloque);
+        Assert.Equal("Litige en cours", client.RaisonBlocage);
+        Assert.True(client.EstArchive);
+
+        Assert.NotNull(client.AdressePrincipale);
+        Assert.True(client.AdressePrincipale!.EstPrincipale);
+        Assert.Equal("Mairie", client.AdressePrincipale!.Etiquette);
+        Assert.Equal("69001", client.AdressePrincipale!.AdressePostale!.PostalCode);
+
+        Assert.Equal(42, client.SourceReference!.NumericId);
+        Assert.Equal(DatabaseSchemaVersion.Batik, client.SourceReference!.Source);
+    }
+
+    // ---- 3. Adresse Batik ---------------------------------------------------------
+
+    [Fact]
+    public void AdresseBatik_MapsLinesAndFillsLine3FromLine4Line5WhenEmpty()
+    {
+        var complete = new BatikModels.AdresseRow
+        {
+            ADPKID = 5,
+            ADEtiquette = "Siège",
+            ADLigne1 = "M. Dupont",
+            ADLigne2 = "Service comptabilité",
+            ADLigne3 = "Bâtiment A",
+            ADLigne4 = "12 rue de la Paix",
+            ADLigne5 = "ZI Nord",
+            ADCodePostal = "69001",
+            ADVille = "Lyon",
+            ADPresentation = "bloc courrier"
+        };
+
+        CanonicalMappingResult<Adresse> result = BatikMappers.BatikAdresseMapper.Map(complete);
+
+        Adresse adresse = result.Value;
+        Assert.Equal(DatabaseSchemaVersion.Batik, result.SourceVersion);
+        Assert.Equal("Siège", adresse.Etiquette);
+        Assert.Equal("M. Dupont", adresse.AdressePostale!.Line1);
+        Assert.Equal("Service comptabilité", adresse.AdressePostale!.Line2);
+        Assert.Equal("Bâtiment A", adresse.AdressePostale!.Line3);
+        Assert.Equal("69001", adresse.AdressePostale!.PostalCode);
+        Assert.Equal("Lyon", adresse.AdressePostale!.City);
+        Assert.Equal(5, adresse.SourceReference!.NumericId);
+        Assert.Contains(result.IgnoredFields, f => f == "AD_Presentation");
+
+        var withoutLine3 = new BatikModels.AdresseRow
+        {
+            ADPKID = 6,
+            ADLigne1 = "M. Dupont",
+            ADLigne4 = "12 rue de la Paix",
+            ADLigne5 = "ZI Nord",
+            ADCodePostal = "69001",
+            ADVille = "Lyon"
+        };
+
+        CanonicalMappingResult<Adresse> result2 = BatikMappers.BatikAdresseMapper.Map(withoutLine3);
+        Assert.Equal("12 rue de la Paix ZI Nord", result2.Value.AdressePostale!.Line3);
+    }
+
+    // ---- 4. Client Omika avec GUID valide ----------------------------------------
+
+    [Fact]
+    public void ClientOmika_ValidGuid_KeepsEntityGuidAndPhysicalGuid()
+    {
+        var row = new OmikaModels.ClientRow
+        {
+            CLPKID = 7,
+            GUID = "550e8400-e29b-41d4-a716-446655440000",
+            CLNom = "SARL Omika"
+        };
+
+        CanonicalMappingResult<Client> result = OmikaMappers.OmikaClientMapper.Map(row);
+
+        Assert.Equal(DatabaseSchemaVersion.Omika, result.SourceVersion);
+        Assert.NotNull(result.Value.SourceReference!.EntityGuid);
+        Assert.Equal(
+            "550e8400-e29b-41d4-a716-446655440000",
+            result.Value.SourceReference!.EntityGuid!.Value.ToString("D"));
+        Assert.Equal("550e8400-e29b-41d4-a716-446655440000", result.Value.SourceReference!.PhysicalGuid);
+
+        Assert.Equal(7, result.Value.SourceReference!.NumericId);
+        Assert.Equal("SARL Omika", result.Value.Nom);
+    }
+
+    // ---- 5. Client Omika avec GUID sans tirets ------------------------------------
+
+    [Fact]
+    public void ClientOmika_GuidWithoutDashes_IsParsedByTryParse()
+    {
+        var row = new OmikaModels.ClientRow
+        {
+            CLPKID = 8,
+            GUID = "550e8400e29b41d4a716446655440000"
+        };
+
+        CanonicalMappingResult<Client> result = OmikaMappers.OmikaClientMapper.Map(row);
+
+        Assert.NotNull(result.Value.SourceReference!.EntityGuid);
+        Assert.Equal(
+            "550e8400-e29b-41d4-a716-446655440000",
+            result.Value.SourceReference!.EntityGuid!.Value.ToString("D"));
+        Assert.Empty(result.Warnings);
+
+    }
+
+    // ---- 6. Client Omika avec GUID invalide ---------------------------------------
+
+    [Fact]
+    public void ClientOmika_InvalidGuid_ProducesNullGuidAndWarningWithoutException()
+    {
+        var row = new OmikaModels.ClientRow
+        {
+            CLPKID = 9,
+            GUID = "not-a-guid",
+            CLNom = "Société inconnue"
+        };
+
+        CanonicalMappingResult<Client> result = OmikaMappers.OmikaClientMapper.Map(row);
+
+        Assert.Null(result.Value.SourceReference!.EntityGuid);
+        Assert.Equal("not-a-guid", result.Value.SourceReference!.PhysicalGuid);
+        Assert.Contains(result.Warnings, w => w.StartsWith(MappingWarningCodes.InvalidPhysicalGuid, StringComparison.Ordinal));
+        Assert.Equal("Société inconnue", result.Value.Nom);
+    }
+
+    // ---- 7. Adresse Omika ----------------------------------------------------------
+
+    [Fact]
+    public void AdresseOmika_NativeMemoIsPreferredOverZombieLines()
+    {
+        var row = new OmikaModels.AdresseRow
+        {
+            ADPKID = 11,
+            GUID = "1f0e8400-e29b-41d4-a716-446655441111",
+            ADEtiquette = "Agence Lyon",
+            ADAdresse = "12 rue de la Paix",
+            ADLigne1 = "ancienne ligne 1",
+            ADCodePostal = "69001",
+            ADVille = "Lyon"
+        };
+
+        CanonicalMappingResult<Adresse> result = OmikaMappers.OmikaAdresseMapper.Map(row);
+
+        Assert.Equal(DatabaseSchemaVersion.Omika, result.SourceVersion);
+        Assert.Equal("12 rue de la Paix", result.Value.AdressePostale!.Line1);
+        Assert.Equal("Agence Lyon", result.Value.Etiquette);
+        Assert.Equal("69001", result.Value.AdressePostale!.PostalCode);
+        Assert.Equal("Lyon", result.Value.AdressePostale!.City);
+        Assert.DoesNotContain(result.Warnings, w => w.StartsWith(MappingWarningCodes.ZombieFieldUsedAsFallback, StringComparison.Ordinal));
+        Assert.NotNull(result.Value.SourceReference!.EntityGuid);
+    }
+
+    [Fact]
+    public void AdresseOmika_WithoutNativeMemo_UsesZombieLinesAsDocumentedFallback()
+    {
+        var row = new OmikaModels.AdresseRow
+        {
+            ADPKID = 12,
+            ADLigne1 = "M. Dupont",
+            ADLigne2 = "Service comptabilité",
+            ADCodePostal = "69002",
+            ADVille = "Lyon"
+        };
+
+        CanonicalMappingResult<Adresse> result = OmikaMappers.OmikaAdresseMapper.Map(row);
+
+        Assert.Equal("M. Dupont", result.Value.AdressePostale!.Line1);
+        Assert.Equal("Service comptabilité", result.Value.AdressePostale!.Line2);
+        Assert.Contains(result.Warnings, w => w.StartsWith(MappingWarningCodes.ZombieFieldUsedAsFallback, StringComparison.Ordinal));
+    }
+
+    // ---- 8. Priorité de la clé métier Omika ----------------------------------------
+
+    [Fact]
+    public void ClientOmika_BusinessKeyIsPreferredAndLegacyIdIsKeptAsCompatibility()
+    {
+        var referenceRows = new Dictionary<string, OmikaModels.ParametreMetierRow>
+        {
+            ["ENT"] = new() { PAPKID = 50, PACLE = "ENT", PALibelle = "Entreprise", PACategorie = "TYPE" }
+        };
+
+        var row = new OmikaModels.ClientRow
+        {
+            CLPKID = 13,
+            CLCleType = "ENT",
+            CLIDType = 99, // zombie : ancien identifiant
+            CLCleStatut = null,
+            CLIDStatut = 5 // zombie : ancien identifiant, pas de clé métier
+        };
+
+        CanonicalMappingResult<Client> result = OmikaMappers.OmikaClientMapper.Map(row, referenceRows);
+
+        Assert.Equal("ENT", result.Value.Type!.Key);
+        Assert.Equal("Entreprise", result.Value.Type!.Label);
+        Assert.Equal(99, result.Value.Type!.LegacyId);
+
+        Assert.NotNull(result.Value.Statut);
+        Assert.Equal(5, result.Value.Statut!.LegacyId);
+        Assert.Null(result.Value.Statut!.Key);
+        Assert.Contains(result.Warnings, w => w.StartsWith(MappingWarningCodes.ZombieFieldUsedAsFallback, StringComparison.Ordinal));
+    }
+
+    // ---- 9. Conservation des identifiants sources ----------------------------------
+
+    [Fact]
+    public void SourceIdentifiers_ArePreservedOnBothSchemas()
+    {
+        var batik = new BatikModels.ClientRow { CLPKID = 1234, CLIDImport = "IMP-B" };
+        CanonicalMappingResult<Client> batikResult = BatikMappers.BatikClientMapper.Map(batik);
+        Assert.Equal(DatabaseSchemaVersion.Batik, batikResult.Value.SourceReference!.Source);
+        Assert.Equal(1234, batikResult.Value.SourceReference!.NumericId);
+        Assert.Equal("IMP-B", batikResult.Value.SourceReference!.ImportId);
+        Assert.Null(batikResult.Value.SourceReference!.EntityGuid);
+
+        var omika = new OmikaModels.ClientRow
+        {
+            CLPKID = 5678,
+            GUID = "550e8400-e29b-41d4-a716-446655440000",
+            CLIDImport = "IMP-O"
+        };
+        CanonicalMappingResult<Client> omikaResult = OmikaMappers.OmikaClientMapper.Map(omika);
+        Assert.Equal(DatabaseSchemaVersion.Omika, omikaResult.Value.SourceReference!.Source);
+        Assert.Equal(5678, omikaResult.Value.SourceReference!.NumericId);
+        Assert.Equal("IMP-O", omikaResult.Value.SourceReference!.ImportId);
+        Assert.NotNull(omikaResult.Value.SourceReference!.EntityGuid);
+    }
+
+    // ---- 10. Aucune exception sur les valeurs historiques ou nulles ----------------
+
+    [Fact]
+    public void Mapping_HistoricalOrNullValues_NeverThrow()
+    {
+        var batikClient = new BatikModels.ClientRow();
+        BatikMappers.BatikClientMapper.Map(batikClient);
+
+        var batikAdresse = new BatikModels.AdresseRow();
+        BatikMappers.BatikAdresseMapper.Map(batikAdresse);
+
+        var batikRef = new BatikModels.ParametreMetierRow();
+        BatikMappers.BatikReferenceValueMapper.Map(batikRef);
+
+        var omikaClient = new OmikaModels.ClientRow();
+        OmikaMappers.OmikaClientMapper.Map(omikaClient);
+
+        var omikaAdresse = new OmikaModels.AdresseRow();
+        OmikaMappers.OmikaAdresseMapper.Map(omikaAdresse);
+
+        var omikaRef = new OmikaModels.ParametreMetierRow();
+        OmikaMappers.OmikaReferenceValueMapper.Map(omikaRef);
+
+        var omikaClientLegacy = new OmikaModels.ClientRow { CLIDType = 12, CLIDStatut = 0 };
+        CanonicalMappingResult<Client> legacyResult = OmikaMappers.OmikaClientMapper.Map(omikaClientLegacy);
+        Assert.NotNull(legacyResult.Value.Type);
+        Assert.Equal(12, legacyResult.Value.Type!.LegacyId);
+
+        var omikaClientNullGuid = new OmikaModels.ClientRow { GUID = null! };
+        Assert.NotNull(OmikaMappers.OmikaClientMapper.Map(omikaClientNullGuid).Value);
+    }
+
+    // ---- 11. Présence des avertissements attendus ----------------------------------
+
+    [Fact]
+    public void Warnings_AreRaisedForInvalidGuidAndUnresolvedReference()
+    {
+        // GUID invalide.
+        var invalidGuid = new OmikaModels.ClientRow { CLPKID = 21, GUID = "zzz" };
+        CanonicalMappingResult<Client> invalidGuidResult = OmikaMappers.OmikaClientMapper.Map(invalidGuid);
+        Assert.Contains(invalidGuidResult.Warnings, w => w.StartsWith(MappingWarningCodes.InvalidPhysicalGuid, StringComparison.Ordinal));
+
+        // Référentiel Batik non résolu.
+        var unresolved = new BatikModels.ClientRow { CLPKID = 22, CLIDType = 77 };
+        CanonicalMappingResult<Client> unresolvedResult = BatikMappers.BatikClientMapper.Map(unresolved);
+        Assert.Contains(unresolvedResult.Warnings, w => w.Contains(MappingWarningCodes.UnresolvedReference, StringComparison.Ordinal));
+
+
+        // Clé métier absente sur une valeur de référentiel Omika.
+        var noKey = new OmikaModels.ParametreMetierRow { PAPKID = 30, PALibelle = "Actif" };
+        CanonicalMappingResult<ReferenceValue> noKeyResult = OmikaMappers.OmikaReferenceValueMapper.Map(noKey);
+        Assert.Contains(noKeyResult.Warnings, w => w.StartsWith(MappingWarningCodes.MissingBusinessKey, StringComparison.Ordinal));
+        Assert.Equal("Actif", noKeyResult.Value.Label);
+
+        // Libellé absent : jamais inventé, simple avertissement.
+        var noLabel = new BatikModels.ParametreMetierRow { PAPKID = 31, PACode = "T", PAValeur = "1" };
+        CanonicalMappingResult<ReferenceValue> noLabelResult = BatikMappers.BatikReferenceValueMapper.Map(noLabel);
+        Assert.Contains(noLabelResult.Warnings, w => w.StartsWith(MappingWarningCodes.EmptyReferenceLabel, StringComparison.Ordinal));
+        Assert.Equal(string.Empty, noLabelResult.Value.Label);
+        Assert.Equal(31, noLabelResult.Value.LegacyId);
+    }
+
+    // ---- 12. Absence de noms HFSQL dans le domaine canonique ------------------------
+
+    [Fact]
+    public void CanonicalDomain_DoesNotExposeHfSqlNames()
+    {
+        var row = new OmikaModels.ClientRow
+        {
+            CLPKID = 40,
+            GUID = "550e8400-e29b-41d4-a716-446655440000",
+            CLNom = "SARL Test",
+            CLIDType = 0,
+            CLCleType = null,
+            CLIDStatut = 0,
+            CLCodeTVA = "FR123",
+            CLEmail = "test@test.fr",
+            Archive = false
+        };
+
+        CanonicalMappingResult<Client> result = OmikaMappers.OmikaClientMapper.Map(row);
+        Client client = result.Value;
+
+        string[] forbidden =
+        [
+            "CL_", "AD_", "PA_", "PKID", "HfSql", "HFSQL", "Ligne_", "GUID"
+        ];
+
+        AssertHasNoPhysicalNames(client, forbidden);
+        AssertHasNoPhysicalNames(client.AdressePrincipale ?? new Adresse(), forbidden);
+
+        if (client.Coordonnees is not null)
+        {
+            AssertHasNoPhysicalNames(client.Coordonnees, forbidden);
+        }
+
+        if (client.SourceReference is not null)
+        {
+            AssertHasNoPhysicalNames(client.SourceReference, forbidden);
+        }
+    }
+
+    // ---- Référentiels ----------------------------------------------------------------
+
+    [Fact]
+    public void BatikReferenceValue_MapFavorsLegacyIdCodeAndLabel()
+    {
+        var row = new BatikModels.ParametreMetierRow
+        {
+            PAPKID = 60,
+            PACode = "T",
+            PAValeur = "1",
+            PALibelle = "Régie"
+        };
+
+        CanonicalMappingResult<ReferenceValue> result = BatikMappers.BatikReferenceValueMapper.Map(row);
+
+        Assert.Equal("Régie", result.Value.Label);
+        Assert.Equal(60, result.Value.LegacyId);
+        Assert.Equal("T", result.Value.Code);
+        Assert.Null(result.Value.Key);
+    }
+
+    [Fact]
+    public void OmikaReferenceValue_MapFavorsBusinessKeyAndKeepsLegacyIdAsCompatibility()
+    {
+        var row = new OmikaModels.ParametreMetierRow
+        {
+            PAPKID = 61,
+            PACLE = "ACT",
+            PALibelle = "Actif",
+            PACategorie = "STATUT"
+        };
+
+        CanonicalMappingResult<ReferenceValue> result = OmikaMappers.OmikaReferenceValueMapper.Map(row);
+
+        Assert.Equal("Actif", result.Value.Label);
+        Assert.Equal("ACT", result.Value.Key);
+        Assert.Equal(61, result.Value.LegacyId);
+        Assert.Equal("STATUT", result.Value.Code);
+    }
+
+    [Fact]
+    public void OmikaReferenceValue_MapByKey_UsesInMemoryDictionary()
+    {
+        var referenceRows = new Dictionary<string, OmikaModels.ParametreMetierRow>
+        {
+            ["RGE"] = new() { PAPKID = 70, PACLE = "RGE", PALibelle = "Régie", PACategorie = "TYPE" }
+        };
+
+        CanonicalMappingResult<ReferenceValue>? resolved = OmikaMappers.OmikaReferenceValueMapper.MapByKey("RGE", referenceRows);
+
+        Assert.NotNull(resolved);
+        Assert.Equal("Régie", resolved!.Value.Label);
+        Assert.Equal("RGE", resolved.Value.Key);
+    }
+
+    // ---- Helper ---------------------------------------------------------------------
+
+    private static void AssertHasNoPhysicalNames(object value, string[] forbidden)
+    {
+        foreach (var property in value.GetType().GetProperties())
+        {
+            Assert.DoesNotContain(forbidden, f => property.Name.Contains(f, StringComparison.Ordinal));
+        }
+    }
+}