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,305 @@
+using System.Data;
+using System.Data.Common;
+using Omika.Data.Configuration;
+using Omika.Data.Connection;
+using Omika.Data.HfSql.Connection;
+
+namespace Omika.Tests.Connection;
+
+public class LicenseOleDbConnectionTests
+{
+    private static LicenseConnectionOptions CreateOptions() => new()
+    {
+        Server = "127.0.0.1",
+        Port = 4900,
+        DatabaseName = "BASE_LICENSES",
+        Login = "susana",
+        Password = "secret",
+        FilePasswords = new LicenseFilePasswordOptions
+        {
+            ProtectionStd = "STD_PASSWORD",
+            ProtectionPlus = null
+        }
+    };
+
+    [Fact]
+    public void CreateForLicense_MapsAllFields()
+    {
+        var options = CreateOptions();
+
+        var result = HfSqlConnectionOptionsFactory.CreateForLicense(options);
+
+        Assert.Equal("127.0.0.1", result.Server);
+        Assert.Equal(4900, result.Port);
+        Assert.Equal("BASE_LICENSES", result.Database);
+        Assert.Equal("susana", result.User);
+        Assert.Equal("secret", result.Credential);
+        Assert.Equal("STD_PASSWORD", result.FilePasswords.ProtectionStd);
+        Assert.Null(result.FilePasswords.ProtectionPlus);
+    }
+
+    [Fact]
+    public void CreateForLicense_NullOptions_Throws()
+    {
+        Assert.Throws<ArgumentNullException>(() => HfSqlConnectionOptionsFactory.CreateForLicense(null!));
+    }
+
+    [Fact]
+    public async Task OpenAsync_OpensConnection()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+
+        Assert.Equal(HfsqlConnectionState.Closed, connection.State);
+
+        await connection.OpenAsync();
+
+        Assert.Equal(HfsqlConnectionState.Open, connection.State);
+    }
+
+    [Fact]
+    public async Task OpenAsync_Twice_DoesNotReopen()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+
+        await connection.OpenAsync();
+        await connection.OpenAsync();
+
+        Assert.Equal(HfsqlConnectionState.Open, connection.State);
+        Assert.Equal(1, factory.OpenCount);
+    }
+
+    [Fact]
+    public async Task CloseAsync_ClosesConnection()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+
+        await connection.OpenAsync();
+        await connection.CloseAsync();
+
+        Assert.Equal(HfsqlConnectionState.Closed, connection.State);
+    }
+
+    [Fact]
+    public async Task QueryAsync_ReturnsRows()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+        await connection.OpenAsync();
+
+        var rows = await connection.QueryAsync("SELECT * FROM Licence");
+
+        Assert.Single(rows);
+        Assert.Equal("LIC-001", rows[0]["NumeroLicence"]);
+    }
+
+    [Fact]
+    public async Task ExecuteScalarAsync_ReturnsValue()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+        await connection.OpenAsync();
+
+        var value = await connection.ExecuteScalarAsync("SELECT COUNT(*) FROM Licence");
+
+        Assert.Equal(1L, value);
+    }
+
+    [Fact]
+    public async Task QueryAsync_NotOpen_Throws()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            () => connection.QueryAsync("SELECT * FROM Licence"));
+    }
+
+    [Fact]
+    public async Task Options_ExposesConnectionName()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+
+        Assert.Equal(LicenseConnectionOptions.ConnectionName, connection.Options.ConnectionName);
+        Assert.Equal("BASE_LICENSES", connection.Options.DatabaseName);
+        Assert.Equal("susana", connection.Options.Login);
+    }
+
+    [Fact]
+    public async Task Options_DoesNotExposePassword()
+    {
+        var factory = new FakeFactory();
+        await using var connection = new LicenseOleDbConnection(CreateOptions(), factory);
+
+        var text = connection.Options.ToString();
+
+        Assert.DoesNotContain("secret", text, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("STD_PASSWORD", text, StringComparison.OrdinalIgnoreCase);
+    }
+
+
+    /// <summary>
+    /// Fabrique simulée qui retourne une connexion factice sans serveur HFSQL.
+    /// </summary>
+    private sealed class FakeFactory : IHfSqlOleDbConnectionFactory
+    {
+        public int OpenCount { get; private set; }
+
+        public DbConnection Create(HfSqlConnectionOptions options, string? extendedProperties = null)
+        {
+            return new FakeConnection(() => OpenCount++);
+        }
+    }
+
+    private sealed class FakeConnection : DbConnection
+    {
+        private readonly Action _onOpen;
+        private ConnectionState _state = ConnectionState.Closed;
+
+        public FakeConnection(Action onOpen)
+        {
+            _onOpen = onOpen;
+        }
+
+        public override string ConnectionString { get; set; } = "";
+        public override string Database => "BASE_LICENSES";
+        public override string DataSource => "127.0.0.1:4900";
+        public override string ServerVersion => "1.0";
+        public override ConnectionState State => _state;
+
+        public override void ChangeDatabase(string databaseName) { }
+
+        public override void Close() => _state = ConnectionState.Closed;
+
+        public override void Open()
+        {
+            _onOpen();
+            _state = ConnectionState.Open;
+        }
+
+        protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel)
+            => throw new NotSupportedException();
+
+        protected override DbCommand CreateDbCommand() => new FakeCommand();
+
+        protected override void Dispose(bool disposing)
+        {
+            _state = ConnectionState.Closed;
+            base.Dispose(disposing);
+        }
+    }
+
+    private sealed class FakeCommand : DbCommand
+    {
+        public override string CommandText { get; set; } = "";
+        public override int CommandTimeout { get; set; }
+        public override CommandType CommandType { get; set; }
+        public override bool DesignTimeVisible { get; set; }
+        public override UpdateRowSource UpdatedRowSource { get; set; }
+        protected override DbConnection? DbConnection { get; set; }
+        protected override DbParameterCollection DbParameterCollection { get; } = new FakeParameterCollection();
+        protected override DbTransaction? DbTransaction { get; set; }
+
+        public override void Cancel() { }
+
+        public override int ExecuteNonQuery() => 0;
+
+        public override object? ExecuteScalar() => 1L;
+
+        public override void Prepare() { }
+
+        protected override DbParameter CreateDbParameter() => new FakeParameter();
+
+        protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior) => new FakeReader();
+    }
+
+    private sealed class FakeReader : DbDataReader
+    {
+        private bool _read;
+
+        public override int FieldCount => 1;
+        public override bool HasRows => true;
+        public override bool IsClosed => false;
+        public override int RecordsAffected => 0;
+        public override object this[int ordinal] => GetValue(ordinal);
+        public override object this[string name] => GetValue(GetOrdinal(name));
+        public override int Depth => 0;
+
+        public override bool GetBoolean(int ordinal) => throw new NotSupportedException();
+        public override byte GetByte(int ordinal) => throw new NotSupportedException();
+        public override long GetBytes(int ordinal, long dataOffset, byte[]? buffer, int bufferOffset, int length)
+            => throw new NotSupportedException();
+        public override char GetChar(int ordinal) => throw new NotSupportedException();
+        public override long GetChars(int ordinal, long dataOffset, char[]? buffer, int bufferOffset, int length)
+            => throw new NotSupportedException();
+        public override string GetDataTypeName(int ordinal) => throw new NotSupportedException();
+        public override DateTime GetDateTime(int ordinal) => throw new NotSupportedException();
+        public override decimal GetDecimal(int ordinal) => throw new NotSupportedException();
+        public override double GetDouble(int ordinal) => throw new NotSupportedException();
+        public override Type GetFieldType(int ordinal) => typeof(string);
+        public override float GetFloat(int ordinal) => throw new NotSupportedException();
+        public override Guid GetGuid(int ordinal) => throw new NotSupportedException();
+        public override short GetInt16(int ordinal) => throw new NotSupportedException();
+        public override int GetInt32(int ordinal) => throw new NotSupportedException();
+        public override long GetInt64(int ordinal) => throw new NotSupportedException();
+        public override string GetName(int ordinal) => "NumeroLicence";
+        public override int GetOrdinal(string name) => name == "NumeroLicence" ? 0 : throw new IndexOutOfRangeException();
+        public override string GetString(int ordinal) => "LIC-001";
+        public override object GetValue(int ordinal) => "LIC-001";
+        public override int GetValues(object[] values)
+        {
+            values[0] = "LIC-001";
+            return 1;
+        }
+        public override bool IsDBNull(int ordinal) => false;
+        public override bool NextResult() => false;
+        public override bool Read()
+        {
+            if (_read)
+                return false;
+            _read = true;
+            return true;
+        }
+        public override System.Collections.IEnumerator GetEnumerator() => Array.Empty<object>().GetEnumerator();
+    }
+
+
+    private sealed class FakeParameterCollection : DbParameterCollection
+    {
+        public override int Count => 0;
+        public override object SyncRoot => this;
+        public override int Add(object value) => 0;
+        public override void AddRange(Array values) { }
+        public override void Clear() { }
+        public override bool Contains(object value) => false;
+        public override bool Contains(string value) => false;
+        public override void CopyTo(Array array, int index) { }
+        public override System.Collections.IEnumerator GetEnumerator() => Array.Empty<object>().GetEnumerator();
+        public override int IndexOf(object value) => -1;
+        public override int IndexOf(string value) => -1;
+        public override void Insert(int index, object value) { }
+        public override void Remove(object value) { }
+        public override void RemoveAt(int index) { }
+        public override void RemoveAt(string parameterName) { }
+        protected override DbParameter GetParameter(int index) => new FakeParameter();
+        protected override DbParameter GetParameter(string parameterName) => new FakeParameter();
+        protected override void SetParameter(int index, DbParameter value) { }
+        protected override void SetParameter(string parameterName, DbParameter value) { }
+    }
+
+    private sealed class FakeParameter : DbParameter
+    {
+        public override DbType DbType { get; set; }
+        public override ParameterDirection Direction { get; set; }
+        public override bool IsNullable { get; set; }
+        public override string ParameterName { get; set; } = "";
+        public override string SourceColumn { get; set; } = "";
+        public override object? Value { get; set; }
+        public override bool SourceColumnNullMapping { get; set; }
+        public override int Size { get; set; }
+        public override void ResetDbType() { }
+    }
+}