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,207 @@
+using System.Text.Json;
+using Omika.Core.Compatibility;
+using Omika.Data.Connection;
+using Omika.Data.HfSql.Connection;
+using Omika.Data.SchemaDetection;
+
+namespace Omika.Tests.Connection;
+
+
+/// <summary>
+/// Tests d'intégration OLE DB HFSQL réels.
+///
+/// Ces tests nécessitent un serveur HFSQL accessible et le provider OLE DB
+/// <c>PCSOFT.HFSQL</c> installé. Ils sont ignorés automatiquement si la
+/// configuration locale n'est pas disponible ou si le serveur est injoignable.
+///
+/// Aucun secret n'est affiché : les assertions portent uniquement sur les
+/// modes d'accès observés.
+/// </summary>
+public class HfSqlOleDbIntegrationTests
+{
+    private const string ConfigPath = @"D:\Avalonia\Omika\config\hfsql-test.local.json";
+
+    private sealed class TestConfig
+    {
+        public int Port { get; set; }
+        public string Server { get; set; } = "";
+        public string ProtectionPlusSecret { get; set; } = "";
+        public FilePasswordsConfig FilePasswords { get; set; } = new();
+        public DatabaseConfig Batik { get; set; } = new();
+        public DatabaseConfig Omika { get; set; } = new();
+    }
+
+    private sealed class FilePasswordsConfig
+    {
+        public string? ProtectionStd { get; set; }
+        public string? ProtectionPlus { get; set; }
+    }
+
+    private sealed class DatabaseConfig
+    {
+        public string Credential { get; set; } = "";
+        public string Database { get; set; } = "";
+        public string User { get; set; } = "";
+        public string? OriginalDatabaseName { get; set; }
+    }
+
+    private static TestConfig? LoadConfig()
+    {
+        if (!File.Exists(ConfigPath))
+            return null;
+
+        try
+        {
+            var json = File.ReadAllText(ConfigPath);
+            return JsonSerializer.Deserialize<TestConfig>(
+                json,
+                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private static HfSqlConnectionOptions BuildOptions(TestConfig config, DatabaseConfig db)
+    {
+        return new HfSqlConnectionOptions
+        {
+            Server = config.Server,
+            Port = config.Port,
+            Database = db.Database,
+            User = db.User,
+            Credential = db.Credential,
+            FilePasswords = new HfSqlFilePasswordOptions
+            {
+                ProtectionStd = config.FilePasswords.ProtectionStd,
+                ProtectionPlus = config.FilePasswords.ProtectionPlus
+            }
+        };
+    }
+
+    [Fact]
+    public async Task ResolveAsync_Batik_Client_IsAccessible()
+    {
+        var config = LoadConfig();
+        if (config is null)
+            return; // config absente : test ignoré
+
+        var options = BuildOptions(config, config.Batik);
+        var factory = new HfSqlOleDbConnectionFactory();
+        var resolver = new HfSqlFileAccessResolver(factory, options);
+
+        var files = new List<HfSqlFileAccessProfile>
+        {
+            new() { LogicalFile = "Client", ExpectedGroup = "ProtectionStd" }
+        };
+
+        try
+        {
+            var result = await resolver.ResolveAsync(files);
+            Assert.True(result["Client"].IsAccessible,
+                $"Client Batik doit être accessible (mode observé : {result["Client"].ObservedAccess})");
+        }
+        catch (Exception ex) when (IsServerUnavailable(ex))
+        {
+            return; // serveur injoignable : test ignoré
+        }
+    }
+
+    [Fact]
+    public async Task ResolveAsync_Omika_Client_IsAccessible()
+    {
+        var config = LoadConfig();
+        if (config is null)
+            return;
+
+        var options = BuildOptions(config, config.Omika);
+        var factory = new HfSqlOleDbConnectionFactory();
+        var resolver = new HfSqlFileAccessResolver(factory, options);
+
+        var files = new List<HfSqlFileAccessProfile>
+        {
+            new() { LogicalFile = "Client", ExpectedGroup = "ProtectionStd" }
+        };
+
+        try
+        {
+            var result = await resolver.ResolveAsync(files);
+            Assert.True(result["Client"].IsAccessible,
+                $"Client Omika doit être accessible (mode observé : {result["Client"].ObservedAccess})");
+        }
+        catch (Exception ex) when (IsServerUnavailable(ex))
+        {
+            return;
+        }
+    }
+
+    // --- Détection de schéma réelle (BATIK_TEST / OMIKA_TEST) -----------------
+
+    [Fact]
+    public async Task DetectAsync_BatikTest_ReturnsBatik()
+    {
+        var config = LoadConfig();
+        if (config is null)
+            return; // config absente : test ignoré
+
+        var options = BuildOptions(config, config.Batik);
+        var factory = new HfSqlOleDbConnectionFactory();
+        await using var connection = new HfSqlOleDbConnection(factory, options);
+        var detector = new DatabaseSchemaDetector(connection);
+
+        try
+        {
+            var result = await detector.DetectAsync();
+            Assert.True(result.IsSuccess,
+                $"La détection Batik a échoué : {string.Join("; ", result.Errors)}");
+            Assert.Equal(DatabaseSchemaVersion.Batik, result.Value);
+        }
+        catch (Exception ex) when (IsServerUnavailable(ex))
+        {
+            return; // serveur injoignable : test ignoré
+        }
+    }
+
+    [Fact]
+    public async Task DetectAsync_OmikaTest_ReturnsOmika()
+    {
+        var config = LoadConfig();
+        if (config is null)
+            return; // config absente : test ignoré
+
+        var options = BuildOptions(config, config.Omika);
+        var factory = new HfSqlOleDbConnectionFactory();
+        await using var connection = new HfSqlOleDbConnection(factory, options);
+        var detector = new DatabaseSchemaDetector(connection);
+
+        try
+        {
+            var result = await detector.DetectAsync();
+            Assert.True(result.IsSuccess,
+                $"La détection Omika a échoué : {string.Join("; ", result.Errors)}");
+            Assert.Equal(DatabaseSchemaVersion.Omika, result.Value);
+        }
+        catch (Exception ex) when (IsServerUnavailable(ex))
+        {
+            return; // serveur injoignable : test ignoré
+        }
+    }
+
+    private static bool IsServerUnavailable(Exception ex)
+    {
+        // Le provider OLE DB peut lever des exceptions natives au teardown.
+        // On ignore les erreurs de connexion (serveur injoignable) mais on
+        // propage les erreurs de logique.
+        var message = ex.Message;
+        return message.Contains("provider", StringComparison.OrdinalIgnoreCase)
+               || message.Contains("serveur", StringComparison.OrdinalIgnoreCase)
+               || message.Contains("server", StringComparison.OrdinalIgnoreCase)
+               || message.Contains("connexion", StringComparison.OrdinalIgnoreCase)
+               || message.Contains("connection", StringComparison.OrdinalIgnoreCase)
+               || message.Contains("E_FAIL", StringComparison.OrdinalIgnoreCase)
+               || message.Contains("0x80004005", StringComparison.OrdinalIgnoreCase);
+    }
+}
+
+