Merge remote-tracking branch 'GH_CSharp/GenFreeWin'

Author: joecare99

GenFreeWin/.github/copilot-instructions.md

@@ -14,6 +14,7 @@ Apply these defaults when working in this repository unless the user explicitly
 - Use BaseLib filesystem abstractions like `BaseLib.Models.Interfaces.IFile` and `BaseLib.Models.FileProxy` to avoid explicit file system dependencies, and add further interfaces/proxy classes when sensible.
 - Note that the `ArtifactsPath/UseArtifactsPath` migration has been rolled back for now because it is a larger separate undertaking and should not be pursued as part of the current parser work.
 - Avoid global usings; each file/class should declare its own usings so dependencies remain explicit.
+- Prefer built-in .NET database abstractions from `System.Data/System.Data.Common` (for example `DbProviderFactory`, `DbConnection`, `DbCommand`, `DbDataReader`, `IDbConnection`) over custom database interface hierarchies when making data access provider-agnostic.
 
 ## Testing
 - Use `MSTest` in the latest practical version for new or updated tests.

GenFreeWin/.info.md

@@ -20,6 +20,72 @@
   - `DevOps\Tasks\T-RNZ-TRAUER-002-Move-database-access-into-repository.md`
   - `DevOps\Tasks\T-RNZ-TRAUER-003-Add-regression-tests-for-mapping-and-delegation.md`
 
+## Domain-Neutral DB Framework Extraction Snapshot
+
+- Target areas:
+  - `GenFreeBase\Interfaces\DB`
+  - `GenDBImplOLEDB`
+- Goal: extract reusable database abstractions and common infrastructure from the current `GenFree*` genealogy context into a domain-neutral database framework.
+- Architectural direction:
+  - isolate provider-neutral contracts and core helpers in neutral projects
+  - keep provider-specific facades separated by database type such as `OleDb`, `MySql`, `SqlServer`, and `dBase`
+  - keep temporary compatibility paths for existing `GenFree*` consumers during migration
+- Initial findings:
+  - several contracts are already generally reusable but still live under `GenFree` namespaces
+  - some interfaces still depend on `GenFree.Data` and other solution-specific types
+  - `GenDBImplOLEDB\Data.DB\MySqlStatementRenderer.cs` appears misplaced in the `OleDb` provider project
+- Planning artifacts:
+  - `DevOps\Features\F-DB-FRAMEWORK-001-Extract-domain-neutral-database-framework.md`
+  - `DevOps\BacklogItems\BI-DB-FRAMEWORK-001-Assess-and-plan-domain-neutral-db-framework-extraction.md`
+  - `DevOps\Tasks\T-DB-FRAMEWORK-001-Inventory-current-db-abstractions-and-couplings.md`
+  - `DevOps\Tasks\T-DB-FRAMEWORK-002-Define-target-neutral-db-project-structure.md`
+  - `DevOps\Tasks\T-DB-FRAMEWORK-003-Plan-incremental-migration-and-compatibility-layer.md`
+  - `DevOps\Tasks\T-DB-FRAMEWORK-004-Plan-test-strategy-for-db-framework-extraction.md`
+- Validation:
+  - planning-only increment, no code build required yet
+- Detailed mapping artifact:
+  - `DevOps\Tasks\T-DB-FRAMEWORK-005-Map-current-types-to-neutral-target-architecture.md`
+- Recommended first extraction slice:
+  - create a neutral SQL-abstractions project first
+  - leave legacy recordset-oriented contracts unchanged in the first increment
+  - relocate the misplaced `MySqlStatementRenderer` out of the `OleDb` provider project
+- Implemented increment 1 changes:
+  - added `DbCoreAbstractions`
+  - added `DbProviderMySql`
+  - added `DbProviderMySqlTests`
+  - copied neutral SQL abstraction contracts into `DbCoreAbstractions`
+  - moved `MySqlStatementRenderer` from `GenDBImplOLEDB` to `DbProviderMySql`
+  - removed the misplaced renderer file from the `OleDb` project
+- Browser integration update:
+  - `MSQBrowser` now references `DbCoreAbstractions` and `DbProviderMySql`
+  - `MdbBrowser` now references `DbCoreAbstractions` and `GenDBImplOLEDB`
+  - `MSQBrowser` no longer carries a direct `System.Data.OleDb` package reference only for schema collection naming
+- TFM compatibility update required by existing browser targets:
+  - `DbCoreAbstractions` extended to `net462;net472;net481;net6.0;net7.0;net8.0;net9.0`
+  - `DbProviderMySql` extended to `net462;net472;net481;net6.0;net7.0;net8.0;net9.0`
+  - `GenDBImplOLEDB` extended to `net462;net472;net481;net8.0`
+  - `GenFreeBase` extended to `net462;net472;net481;net6.0;net7.0;net8.0;net9.0`
+- Validation update:
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\MSQBrowser\MSQBrowser.csproj -nologo` succeeded
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\MdbBrowser\MdbBrowser.csproj -nologo` succeeded
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\GenDBImplOLEDB\GenDBImplOLEDB.csproj -nologo` succeeded
+- Browser model refactoring update:
+  - `MSQBrowser.Models.DBModel` now creates its connection through `Db.Provider.MySql.MySqlDbConnectionFactory`
+  - `MdbBrowser.Models.DBModel` now creates its connection through `GenFree.Data.DB.OleDbConnectionFactory`
+  - `DbProviderMySql` now exposes `MySqlDbConnectionFactory`
+  - `GenDBImplOLEDB` now exposes `OleDbConnectionFactory`
+  - `GenDBImplOLEDB` now also exposes an initial `OleDbStatementRenderer`
+- Current limitation:
+  - browser model command/adaptor logic is still partly provider-specific and remains a later extraction step
+- Validation update:
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\DbProviderMySql\DbProviderMySql.csproj -nologo` succeeded
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\MSQBrowser\MSQBrowser.csproj -nologo` succeeded
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\MdbBrowser\MdbBrowser.csproj -nologo` succeeded
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\MSQBrowserTests\MSQBrowserTests.csproj -nologo -v:minimal` succeeded
+  - `dotnet build C:\Projekte\CSharp\Gen_FreeWin\MdbBrowserTests\MdbBrowserTests.csproj -nologo` succeeded
+- Unrelated broader-solution follow-up:
+  - `WinAhnenNew\RnzTrauer` still expects a `MySqlStatementRenderer` in its own context and fails during full-solution build; not part of the browser scope
+
 ## FBParser Pascal-to-CSharp Port Snapshot
 
 - Target area: `FBParser\FBEntryParser.cs`

GenFreeWin/DbCoreAbstractions.UnitTests/DbCoreAbstractions.UnitTests.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <TargetFramework>net462</TargetFramework>
+    <IsTestProject>true</IsTestProject>
+    <IsPackable>false</IsPackable>
+    <LangVersion>latest</LangVersion>
+    <DisableTransitiveProjectReferences>false</DisableTransitiveProjectReferences>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MSTest" Version="4.2.2" />
+    <PackageReference Include="NSubstitute" Version="5.3.0" />
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DbCoreAbstractions\DbCoreAbstractions.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+  </ItemGroup>
+
+</Project>

GenFreeWin/DbCoreAbstractions.UnitTests/Sql/DbFilterClauseTests.cs

@@ -0,0 +1,73 @@
+using System;
+using Db.Core.Abstractions.Sql;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace DbCoreAbstractions.UnitTests.Sql
+{
+    /// <summary>
+    /// Unit tests for the <see cref="DbFilterClause"/> constructor.
+    /// </summary>
+    [TestClass]
+    public class DbFilterClauseTests
+    {
+        /// <summary>
+        /// Tests that the constructor correctly assigns all properties when all arguments are provided.
+        /// </summary>
+        [TestMethod]
+        public void Constructor_AllArgumentsProvided_PropertiesAssignedCorrectly()
+        {
+            // Arrange
+            string field = "TestField";
+            DbFilterOperator op = DbFilterOperator.Equal;
+            string parameterName = "@param";
+
+            // Act
+            var clause = new DbFilterClause(field, op, parameterName);
+
+            // Assert
+            Assert.AreEqual(field, clause.Field);
+            Assert.AreEqual(op, clause.Operator);
+            Assert.AreEqual(parameterName, clause.ParameterName);
+        }
+
+        /// <summary>
+        /// Tests that the constructor assigns ParameterName to null when not provided.
+        /// </summary>
+        [TestMethod]
+        public void Constructor_ParameterNameNotProvided_ParameterNameIsNull()
+        {
+            // Arrange
+            string field = "TestField";
+            DbFilterOperator op = DbFilterOperator.IsNull;
+
+            // Act
+            var clause = new DbFilterClause(field, op);
+
+            // Assert
+            Assert.AreEqual(field, clause.Field);
+            Assert.AreEqual(op, clause.Operator);
+            Assert.IsNull(clause.ParameterName);
+        }
+
+        /// <summary>
+        /// Tests that the constructor allows an empty string for field and parameterName.
+        /// </summary>
+        [TestMethod]
+        public void Constructor_EmptyStrings_PropertiesAssignedCorrectly()
+        {
+            // Arrange
+            string field = string.Empty;
+            DbFilterOperator op = DbFilterOperator.Equal;
+            string parameterName = string.Empty;
+
+            // Act
+            var clause = new DbFilterClause(field, op, parameterName);
+
+            // Assert
+            Assert.AreEqual(field, clause.Field);
+            Assert.AreEqual(op, clause.Operator);
+            Assert.AreEqual(parameterName, clause.ParameterName);
+        }
+
+    }
+}

GenFreeWin/DbCoreAbstractions.UnitTests/Sql/DbInsertStatementTests.cs

@@ -0,0 +1,94 @@
+#nullable enable
+
+// <auto-generated>
+// This file contains unit tests for the DbInsertStatement constructor in the DbCoreAbstractions.Sql namespace.
+// It is designed to maximize code coverage for all not-covered lines in the constructor.
+//
+// MSTest v4.2.2, NSubstitute v5.3.0
+//
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Db.Core.Abstractions.Sql;
+using Db.Core.Abstractions.Sql;
+using Db.Core.Abstractions.Sql.Interfaaces;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NSubstitute;
+
+namespace DbCoreAbstractions.UnitTests
+{
+    /// <summary>
+    /// Unit tests for the <see cref="DbInsertStatement"/> constructor.
+    /// </summary>
+    [TestClass]
+    public class DbInsertStatementTests
+    {
+        [TestMethod]
+        [DataRow(null)]
+        [DataRow("")]
+        [DataRow("   ")]
+        public void Ctor_TableIsNullOrWhiteSpace_ThrowsArgumentException(string? table)
+        {
+            // Arrange
+            IEnumerable<KeyValuePair<string, string>>? fields = null;
+            IEnumerable<IDbFilterClause>? filters = null;
+            int? limit = null;
+
+            // Act & Assert
+            try
+            {
+                _ = new DbInsertStatement(table!, fields, filters, limit);
+                Assert.Fail("Expected ArgumentException was not thrown.");
+            }
+            catch (ArgumentException ex)
+            {
+                Assert.AreEqual("A table name is required.", ex.Message.Split(new[] { Environment.NewLine }, StringSplitOptions.None)[0]);
+                Assert.AreEqual("table", ex.ParamName);
+            }
+        }
+
+        [TestMethod]
+        public void Ctor_ValidTableAndNullFields_FieldsIsEmptyArray()
+        {
+            // Arrange
+            string table = "MyTable";
+            IEnumerable<KeyValuePair<string, string>>? fields = null;
+            IEnumerable<IDbFilterClause>? filters = null;
+            int? limit = null;
+
+            // Act
+            var stmt = new DbInsertStatement(table, fields, filters, limit);
+
+            // Assert
+            Assert.AreEqual(table, stmt.Table);
+            Assert.IsNotNull(stmt.Fields);
+            Assert.AreEqual(0, stmt.Fields.Count);
+        }
+
+        [TestMethod]
+        public void Ctor_ValidTableAndFields_FieldsIsArrayWithValues()
+        {
+            // Arrange
+            string table = "MyTable";
+            var fields = new List<KeyValuePair<string, string>>
+            {
+                new("Col1", "Val1"),
+                new("Col2", "Val2")
+            };
+            IEnumerable<IDbFilterClause>? filters = null;
+            int? limit = null;
+
+            // Act
+            var stmt = new DbInsertStatement(table, fields, filters, limit);
+
+            // Assert
+            Assert.AreEqual(table, stmt.Table);
+            Assert.IsNotNull(stmt.Fields);
+            Assert.AreEqual(2, stmt.Fields.Count);
+            Assert.AreEqual("Col1", stmt.Fields[0].Key);
+            Assert.AreEqual("Val1", stmt.Fields[0].Value);
+            Assert.AreEqual("Col2", stmt.Fields[1].Key);
+            Assert.AreEqual("Val2", stmt.Fields[1].Value);
+        }
+    }
+}