551 lines
16 KiB
C#
551 lines
16 KiB
C#
using Omika.Data.HfSql.Mapping;
|
|
using BatikClientRow = Omika.Data.HfSql.Models.Batik.ClientRow;
|
|
using OmikaClientRow = Omika.Data.HfSql.Models.Omika.ClientRow;
|
|
using BatikAdresseRow = Omika.Data.HfSql.Models.Batik.AdresseRow;
|
|
using BatikPersonneRow = Omika.Data.HfSql.Models.Batik.PersonneRow;
|
|
using BatikLieuRow = Omika.Data.HfSql.Models.Batik.LieuRow;
|
|
using BatikParametreMetierRow = Omika.Data.HfSql.Models.Batik.ParametreMetierRow;
|
|
|
|
namespace Omika.Tests.HfSql.Mapping;
|
|
|
|
/// <summary>
|
|
/// Tests unitaires de <see cref="HfsqlRowMapper"/> : conversion d'un résultat
|
|
/// tabulaire physique (dictionnaire colonne → valeur) vers un modèle Row
|
|
/// physique généré. Aucune base réelle, aucun HFSQL, aucun ODBC.
|
|
/// </summary>
|
|
public class HfsqlRowMapperTests
|
|
{
|
|
// ---- 1. ClientRow Batik minimal ------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_BatikClientRow_Minimal_MapsCorrectly()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 42L,
|
|
["CL_Nom"] = "Ville de Lyon",
|
|
["CL_CodeClient"] = "C001",
|
|
["CL_Blocage"] = true,
|
|
["Archive"] = false
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(42L, row.CLPKID);
|
|
Assert.Equal("Ville de Lyon", row.CLNom);
|
|
Assert.Equal("C001", row.CLCodeClient);
|
|
Assert.True(row.CLBlocage);
|
|
Assert.False(row.Archive);
|
|
}
|
|
|
|
// ---- 2. ClientRow Omika minimal ------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_OmikaClientRow_Minimal_MapsCorrectly()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 7L,
|
|
["CL_Nom"] = "Mairie de Paris",
|
|
["CL_CleType"] = "COLLECTIVITE",
|
|
["CL_CleStatut"] = "ACTIF",
|
|
["GUID"] = "abc-123"
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<OmikaClientRow>(values);
|
|
|
|
Assert.Equal(7L, row.CLPKID);
|
|
Assert.Equal("Mairie de Paris", row.CLNom);
|
|
Assert.Equal("COLLECTIVITE", row.CLCleType);
|
|
Assert.Equal("ACTIF", row.CLCleStatut);
|
|
Assert.Equal("abc-123", row.GUID);
|
|
}
|
|
|
|
// ---- 3. Colonne numérique long -------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_LongColumn_MapsValue()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 123456789L,
|
|
["CL_IDType"] = 5L
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(123456789L, row.CLPKID);
|
|
Assert.Equal(5L, row.CLIDType);
|
|
}
|
|
|
|
// ---- 4. String -----------------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_StringColumn_MapsValue()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_Nom"] = "Entreprise Dupont",
|
|
["CL_Email"] = "contact@dupont.fr"
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal("Entreprise Dupont", row.CLNom);
|
|
Assert.Equal("contact@dupont.fr", row.CLEmail);
|
|
}
|
|
|
|
// ---- 5. Bool natif -------------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_BoolNative_MapsValue()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_Blocage"] = true,
|
|
["Archive"] = false
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.True(row.CLBlocage);
|
|
Assert.False(row.Archive);
|
|
}
|
|
|
|
// ---- 6. Bool depuis 0 ----------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_BoolFromZero_IsFalse()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_Blocage"] = 0L
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.False(row.CLBlocage);
|
|
}
|
|
|
|
// ---- 7. Bool depuis 1 ----------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_BoolFromOne_IsTrue()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_Blocage"] = 1L
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.True(row.CLBlocage);
|
|
}
|
|
|
|
// ---- 8. Null vers propriété nullable/référence --------------------------------
|
|
|
|
[Fact]
|
|
public void Map_NullToNullable_IsNull()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_Nom"] = null,
|
|
["CL_Email"] = null
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Null(row.CLNom);
|
|
Assert.Null(row.CLEmail);
|
|
}
|
|
|
|
// ---- 9. Null vers valeur non nullable => défaut -------------------------------
|
|
|
|
[Fact]
|
|
public void Map_NullToNonNullable_KeepsDefault()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = null,
|
|
["CL_Blocage"] = null
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(0L, row.CLPKID);
|
|
Assert.False(row.CLBlocage);
|
|
}
|
|
|
|
// ---- 10. Colonne absente => propriété par défaut ------------------------------
|
|
|
|
[Fact]
|
|
public void Map_MissingColumn_KeepsDefault()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 1L
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(1L, row.CLPKID);
|
|
Assert.Null(row.CLNom);
|
|
Assert.Null(row.CLCodeClient);
|
|
Assert.False(row.CLBlocage);
|
|
}
|
|
|
|
// ---- 11. Mapping insensible à la casse ----------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_ColumnNameCaseInsensitive()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["cl_pkid"] = 9L,
|
|
["CL_NOM"] = "Casé",
|
|
["Cl_Blocage"] = true
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(9L, row.CLPKID);
|
|
Assert.Equal("Casé", row.CLNom);
|
|
Assert.True(row.CLBlocage);
|
|
}
|
|
|
|
// ---- 12. Colonnes supplémentaires inconnues => ignorées -----------------------
|
|
|
|
[Fact]
|
|
public void Map_UnknownColumns_AreIgnored()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 1L,
|
|
["COLONNE_INCONNUE"] = "valeur",
|
|
["AUTRE"] = 123
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(1L, row.CLPKID);
|
|
}
|
|
|
|
// ---- 13. Valeur numérique convertible vers le type cible ----------------------
|
|
|
|
[Fact]
|
|
public void Map_NumericConvertible_ConvertsToTargetType()
|
|
{
|
|
// CL_PKID est long : une valeur int doit être convertie.
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 42,
|
|
["CL_IDType"] = 3
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(42L, row.CLPKID);
|
|
Assert.Equal(3L, row.CLIDType);
|
|
}
|
|
|
|
// ---- 14. Type incompatible => exception explicite -----------------------------
|
|
|
|
[Fact]
|
|
public void Map_IncompatibleType_ThrowsExplicitException()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = "pas-un-nombre"
|
|
};
|
|
|
|
var ex = Assert.Throws<InvalidOperationException>(
|
|
() => HfsqlRowMapper.Map<BatikClientRow>(values));
|
|
|
|
Assert.Contains("CL_PKID", ex.Message);
|
|
Assert.Contains("ClientRow", ex.Message);
|
|
Assert.Contains("CLPKID", ex.Message);
|
|
}
|
|
|
|
// ---- 15. Aucun contenu sensible de valeur dans l'exception --------------------
|
|
|
|
[Fact]
|
|
public void Map_Exception_DoesNotContainSensitiveValue()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = "mot-de-passe-secret"
|
|
};
|
|
|
|
var ex = Assert.Throws<InvalidOperationException>(
|
|
() => HfsqlRowMapper.Map<BatikClientRow>(values));
|
|
|
|
Assert.DoesNotContain("mot-de-passe-secret", ex.Message);
|
|
}
|
|
|
|
// ---- 16. Row avec champs HfSqlLegacyField => mappés normalement ---------------
|
|
|
|
[Fact]
|
|
public void Map_LegacyFields_AreMappedNormally()
|
|
{
|
|
// Omika.ClientRow a des champs zombie/legacy (CL_IDType, CL_IDStatut).
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 5L,
|
|
["CL_IDType"] = 2L,
|
|
["CL_IDStatut"] = 1L
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<OmikaClientRow>(values);
|
|
|
|
Assert.Equal(5L, row.CLPKID);
|
|
Assert.Equal(2L, row.CLIDType);
|
|
Assert.Equal(1L, row.CLIDStatut);
|
|
}
|
|
|
|
// ---- 17. AdresseRow ------------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_AdresseRow_MapsCorrectly()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["AD_PKID"] = 10L,
|
|
["AD_Etiquette"] = "Mairie",
|
|
["AD_Ligne_1"] = "1 place de la République",
|
|
["AD_CodePostal"] = "69001",
|
|
["AD_Ville"] = "Lyon"
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikAdresseRow>(values);
|
|
|
|
Assert.Equal(10L, row.ADPKID);
|
|
Assert.Equal("Mairie", row.ADEtiquette);
|
|
Assert.Equal("1 place de la République", row.ADLigne1);
|
|
Assert.Equal("69001", row.ADCodePostal);
|
|
Assert.Equal("Lyon", row.ADVille);
|
|
}
|
|
|
|
// ---- 18. PersonneRow -----------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_PersonneRow_MapsCorrectly()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["PE_PKID"] = 20L,
|
|
["PE_Nom"] = "Dupont",
|
|
["PE_Prenom"] = "Jean",
|
|
["PE_Email"] = "jean.dupont@mail.fr",
|
|
["PE_Actif"] = true
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikPersonneRow>(values);
|
|
|
|
Assert.Equal(20L, row.PEPKID);
|
|
Assert.Equal("Dupont", row.PENom);
|
|
Assert.Equal("Jean", row.PEPrenom);
|
|
Assert.Equal("jean.dupont@mail.fr", row.PEEmail);
|
|
Assert.True(row.PEActif);
|
|
}
|
|
|
|
// ---- 19. LieuRow ---------------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_LieuRow_MapsCorrectly()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["LI_PKID"] = 30L,
|
|
["LI_CodeLieu"] = "SITE-01",
|
|
["LI_IDAdresse"] = 10L,
|
|
["LI_IDClientPrincipal"] = 42L,
|
|
["LI_Blocage"] = false
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikLieuRow>(values);
|
|
|
|
Assert.Equal(30L, row.LIPKID);
|
|
Assert.Equal("SITE-01", row.LICodeLieu);
|
|
Assert.Equal(10L, row.LIIDAdresse);
|
|
Assert.Equal(42L, row.LIIDClientPrincipal);
|
|
Assert.False(row.LIBlocage);
|
|
}
|
|
|
|
// ---- 20. ParametreMetierRow ----------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_ParametreMetierRow_MapsCorrectly()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["PA_PKID"] = 100L,
|
|
["PA_Code"] = "TYP",
|
|
["PA_Libelle"] = "Type de client",
|
|
["PA_Valeur"] = "01",
|
|
["PA_Ordre"] = 3,
|
|
["PA_Actif"] = true
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikParametreMetierRow>(values);
|
|
|
|
Assert.Equal(100L, row.PAPKID);
|
|
Assert.Equal("TYP", row.PACode);
|
|
Assert.Equal("Type de client", row.PALibelle);
|
|
Assert.Equal("01", row.PAValeur);
|
|
Assert.Equal(3, row.PAOrdre);
|
|
Assert.True(row.PAActif);
|
|
}
|
|
|
|
// ---- 21. Plusieurs appels successifs produisent le même résultat --------------
|
|
|
|
[Fact]
|
|
public void Map_RepeatedCalls_AreDeterministic()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 42L,
|
|
["CL_Nom"] = "Ville de Lyon"
|
|
};
|
|
|
|
var first = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
var second = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(first.CLPKID, second.CLPKID);
|
|
Assert.Equal(first.CLNom, second.CLNom);
|
|
}
|
|
|
|
// ---- 22. Utilisation concurrente sans corruption ------------------------------
|
|
|
|
[Fact]
|
|
public void Map_ConcurrentCalls_AreSafe()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 42L,
|
|
["CL_Nom"] = "Ville de Lyon"
|
|
};
|
|
|
|
var results = new BatikClientRow[100];
|
|
Parallel.For(0, results.Length, i =>
|
|
{
|
|
results[i] = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
});
|
|
|
|
foreach (var row in results)
|
|
{
|
|
Assert.Equal(42L, row.CLPKID);
|
|
Assert.Equal("Ville de Lyon", row.CLNom);
|
|
}
|
|
}
|
|
|
|
// ---- 23. Aucune dépendance à ODBC dans l'API publique -------------------------
|
|
|
|
[Fact]
|
|
public void Map_PublicSignature_DoesNotExposeOdbc()
|
|
{
|
|
var method = typeof(HfsqlRowMapper).GetMethod(nameof(HfsqlRowMapper.Map))!;
|
|
|
|
Assert.DoesNotContain("Odbc", method.ReturnType.FullName, StringComparison.Ordinal);
|
|
foreach (var parameter in method.GetParameters())
|
|
{
|
|
Assert.DoesNotContain("Odbc", parameter.ParameterType.FullName, StringComparison.Ordinal);
|
|
}
|
|
}
|
|
|
|
// ---- 24. Aucun type canonique Client/Adresse/Contact/Site dans l'API publique --
|
|
|
|
[Fact]
|
|
public void Map_PublicSignature_DoesNotExposeCanonicalTypes()
|
|
{
|
|
var method = typeof(HfsqlRowMapper).GetMethod(nameof(HfsqlRowMapper.Map))!;
|
|
|
|
Assert.DoesNotContain("Client", method.ReturnType.FullName, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("Adresse", method.ReturnType.FullName, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("Contact", method.ReturnType.FullName, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("Site", method.ReturnType.FullName, StringComparison.Ordinal);
|
|
}
|
|
|
|
// ---- 25. DBNull.Value défensif -------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_DbNull_IsTreatedAsNull()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_Nom"] = DBNull.Value,
|
|
["CL_PKID"] = DBNull.Value
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Null(row.CLNom);
|
|
Assert.Equal(0L, row.CLPKID);
|
|
}
|
|
|
|
// ---- 26. DateTime --------------------------------------------------------------
|
|
|
|
[Fact]
|
|
public void Map_DateTimeColumn_MapsValue()
|
|
{
|
|
var date = new DateTime(2024, 5, 1, 10, 30, 0);
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 1L,
|
|
["CreationDate"] = date
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(date, row.CreationDate);
|
|
}
|
|
|
|
// ---- 27. Valeur nulle vers propriété valeur non nullable ----------------------
|
|
|
|
[Fact]
|
|
public void Map_NullToValueType_KeepsDefault()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = null,
|
|
["CL_IDType"] = null
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(0L, row.CLPKID);
|
|
Assert.Equal(0L, row.CLIDType);
|
|
}
|
|
|
|
// ---- 28. Chaîne NUL-paddée (rubrique « Mémo texte » / largeur fixe) ------------
|
|
|
|
[Fact]
|
|
public void Map_StringWithNulPadding_IsNormalized()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 1L,
|
|
["CL_Nom"] = "Ville de Lyon\u0000\u0000\u0000",
|
|
["CL_CodeClient"] = "C001\u0000\u0000"
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal("Ville de Lyon", row.CLNom);
|
|
Assert.Equal("C001", row.CLCodeClient);
|
|
}
|
|
|
|
[Fact]
|
|
public void Map_StringAllNul_IsNormalizedToEmpty()
|
|
{
|
|
var values = new Dictionary<string, object?>
|
|
{
|
|
["CL_PKID"] = 1L,
|
|
["CL_Nom"] = "\u0000\u0000\u0000"
|
|
};
|
|
|
|
var row = HfsqlRowMapper.Map<BatikClientRow>(values);
|
|
|
|
Assert.Equal(string.Empty, row.CLNom);
|
|
}
|
|
}
|