Add the UseSqlServer() method to specify the database provider to use.

GillesTourreau · GillesTourreau · commit ddee3a044b75 · 2025-09-04T15:18:19.000+02:00
diff --git a/src/Database.Updater/DatabaseUpdaterBuilder.cs b/src/Database.Updater/DatabaseUpdaterBuilder.cs
@@ -40,6 +40,8 @@ public sealed class DatabaseUpdaterBuilder
 
         private readonly IList<string> migrationsAssemblies = new List<string>();
 
+        private IDatabaseProvider? databaseProvider;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="DatabaseUpdaterBuilder"/> class.
         /// </summary>
@@ -82,8 +84,14 @@ public DatabaseUpdaterBuilder UseMigrationsAssembly(Assembly assembly)
         /// Builds an instance of the <see cref="IDatabaseUpdater"/> to perform the migration of the database.
         /// </summary>
         /// <returns>An instance of the <see cref="IDatabaseUpdater"/> to perform the migration of the database.</returns>
+        /// <exception cref="InvalidOperationException">No database provider has been configured.</exception>
         public IDatabaseUpdater Build()
         {
+            if (this.databaseProvider is null)
+            {
+                throw new InvalidOperationException("No database provider has been configured.");
+            }
+
             var rootCommand = new RootCommand($"Upgrade the {this.applicationName} database.")
             {
                 new SqlServerConnectionStringArgument("connection-string")
@@ -113,7 +121,7 @@ public IDatabaseUpdater Build()
                 migrationsAssemblies.Add(this.callingAssembly.GetName().Name!);
             }
 
-            var databaseUpdater = new EntityFrameworkDatabaseUpdater(migrationsAssemblies);
+            var databaseUpdater = new EntityFrameworkDatabaseUpdater(this.databaseProvider, migrationsAssemblies);
 
             rootCommand.Action = CommandHandler.Create<string, int, string, IHost, CancellationToken>(databaseUpdater.UpgradeAsync);
 
@@ -130,6 +138,13 @@ public IDatabaseUpdater Build()
             return new CommandLineDatabaseUpdater(commandLine);
         }
 
+        internal DatabaseUpdaterBuilder UseDatabaseProvider(IDatabaseProvider databaseProvider)
+        {
+            this.databaseProvider = databaseProvider;
+
+            return this;
+        }
+
         private sealed class CommandLineDatabaseUpdater : IDatabaseUpdater
         {
             private readonly CommandLineConfiguration commandLine;
diff --git a/src/Database.Updater/EntityFrameworkDatabaseUpdater.cs b/src/Database.Updater/EntityFrameworkDatabaseUpdater.cs
@@ -6,45 +6,34 @@
 
 namespace PosInformatique.Database.Updater
 {
-    using Microsoft.Data.SqlClient;
     using Microsoft.EntityFrameworkCore;
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Hosting;
     using Microsoft.Extensions.Logging;
 
     internal sealed class EntityFrameworkDatabaseUpdater
     {
+        private readonly IDatabaseProvider databaseProvider;
+
         private readonly IReadOnlyList<string> migrationsAssemblies;
 
-        public EntityFrameworkDatabaseUpdater(IReadOnlyList<string> migrationsAssemblies)
+        public EntityFrameworkDatabaseUpdater(IDatabaseProvider databaseProvider, IReadOnlyList<string> migrationsAssemblies)
         {
+            this.databaseProvider = databaseProvider;
             this.migrationsAssemblies = migrationsAssemblies;
         }
 
-        public async Task<int> UpgradeAsync(string connectionString, int commandTimeout, string accessToken, IHost host, CancellationToken cancellationToken)
+        public async Task<int> UpgradeAsync(string connectionString, int commandTimeout, string? accessToken, IHost host, CancellationToken cancellationToken)
         {
             var loggerFactory = host.Services.GetRequiredService<ILoggerFactory>();
             var logger = loggerFactory.CreateLogger<EntityFrameworkDatabaseUpdater>();
 
-            var connectionStringBuilder = new SqlConnectionStringBuilder(connectionString);
-            connectionStringBuilder.CommandTimeout = commandTimeout;
-
-            using (var connection = new SqlConnection(connectionStringBuilder.ToString()))
+            using (var connection = this.databaseProvider.CreateConnection(connectionString, commandTimeout, accessToken))
             {
-                connection.AccessToken = accessToken;
-
-                var builder = new DbContextOptionsBuilder<DbContext>();
-                builder.UseSqlServer(
+                var builder = this.databaseProvider.CreateDbContextOptionsBuilder(
                     connection,
-                    opt =>
-                    {
-                        foreach (var assembly in this.migrationsAssemblies)
-                        {
-                            opt.MigrationsAssembly(assembly);
-                        }
-
-                        opt.CommandTimeout(commandTimeout);
-                    });
+                    this.migrationsAssemblies,
+                    commandTimeout);
 
                 builder.UseLoggerFactory(loggerFactory);
 
diff --git a/src/Database.Updater/IDatabaseProvider.cs b/src/Database.Updater/IDatabaseProvider.cs
@@ -0,0 +1,37 @@
+﻿//-----------------------------------------------------------------------
+// <copyright file="IDatabaseProvider.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Database.Updater
+{
+    using System.Data.Common;
+    using Microsoft.EntityFrameworkCore;
+
+    /// <summary>
+    /// Represents a database provider.
+    /// </summary>
+    internal interface IDatabaseProvider
+    {
+        /// <summary>
+        /// Creates a <see cref="DbConnection"/> to the database.
+        /// </summary>
+        /// <param name="connectionString">Connection string to the database.</param>
+        /// <param name="commandTimeout">Timeout for the command execution.</param>
+        /// <param name="accessToken">Access token for authentication if need.</param>
+        /// <returns>The <see cref="DbConnection"/> which allows to connect to the database.</returns>
+        DbConnection CreateConnection(string connectionString, int commandTimeout, string? accessToken);
+
+        /// <summary>
+        /// Creates an instance of the <see cref="DbContextOptionsBuilder"/> to create a <see cref="DbContext"/>
+        /// which will be used for the Entity Framework migrations.
+        /// </summary>
+        /// <param name="connection"><see cref="DbConnection"/> to the database.</param>
+        /// <param name="migrationsAssemblies">List of the assemblies that contains the migrations to execute.</param>
+        /// <param name="commandTimeout">Timeout for the command execution.</param>
+        /// <returns>An instance of the <see cref="DbContextOptionsBuilder"/> to create a <see cref="DbContext"/>
+        /// which will be used for the Entity Framework migrations.</returns>
+        DbContextOptionsBuilder CreateDbContextOptionsBuilder(DbConnection connection, IReadOnlyList<string> migrationsAssemblies, int commandTimeout);
+    }
+}
diff --git a/src/Database.Updater/SqlServer/SqlServerDatabaseProvider.cs b/src/Database.Updater/SqlServer/SqlServerDatabaseProvider.cs
@@ -0,0 +1,45 @@
+﻿//-----------------------------------------------------------------------
+// <copyright file="SqlServerDatabaseProvider.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Database.Updater.SqlServer
+{
+    using System.Data.Common;
+    using Microsoft.Data.SqlClient;
+    using Microsoft.EntityFrameworkCore;
+
+    internal sealed class SqlServerDatabaseProvider : IDatabaseProvider
+    {
+        public SqlServerDatabaseProvider()
+        {
+        }
+
+        public DbConnection CreateConnection(string connectionString, int commandTimeout, string? accessToken)
+        {
+            var connectionStringBuilder = new SqlConnectionStringBuilder(connectionString);
+            connectionStringBuilder.CommandTimeout = commandTimeout;
+
+            return new SqlConnection(connectionStringBuilder.ToString())
+            {
+                AccessToken = accessToken,
+            };
+        }
+
+        public DbContextOptionsBuilder CreateDbContextOptionsBuilder(DbConnection connection, IReadOnlyList<string> migrationsAssemblies, int commandTimeout)
+        {
+            return new DbContextOptionsBuilder().UseSqlServer(
+                connection,
+                opt =>
+                {
+                    foreach (var assembly in migrationsAssemblies)
+                    {
+                        opt.MigrationsAssembly(assembly);
+                    }
+
+                    opt.CommandTimeout(commandTimeout);
+                });
+        }
+    }
+}
diff --git a/src/Database.Updater/SqlServer/SqlServerDatabaseUpdaterBuilderExtensions.cs b/src/Database.Updater/SqlServer/SqlServerDatabaseUpdaterBuilderExtensions.cs
@@ -0,0 +1,26 @@
+﻿//-----------------------------------------------------------------------
+// <copyright file="SqlServerDatabaseUpdaterBuilderExtensions.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Database.Updater
+{
+    using PosInformatique.Database.Updater.SqlServer;
+
+    /// <summary>
+    /// Contains extensions methods for the <see cref="DatabaseUpdaterBuilder"/> class to use SQL Server database provider.
+    /// </summary>
+    public static class SqlServerDatabaseUpdaterBuilderExtensions
+    {
+        /// <summary>
+        /// Configures the <see cref="DatabaseUpdaterBuilder"/> to use SQL Server database provider.
+        /// </summary>
+        /// <param name="builder"><see cref="DatabaseUpdaterBuilder"/> to configure.</param>
+        /// <returns>The <paramref name="builder"/> instance to continue the configuration.</returns>
+        public static DatabaseUpdaterBuilder UseSqlServer(this DatabaseUpdaterBuilder builder)
+        {
+            return builder.UseDatabaseProvider(new SqlServerDatabaseProvider());
+        }
+    }
+}
diff --git a/tests/Database.Updater.IntegrationTests/Program.cs b/tests/Database.Updater.IntegrationTests/Program.cs
@@ -13,6 +13,7 @@ public static async Task Main(string[] args)
             var databaseUpdaterBuilder = new DatabaseUpdaterBuilder("MyApplication");
 
             var updater = databaseUpdaterBuilder
+                .UseSqlServer()
                 .UseMigrationsAssembly(typeof(MigrationsAssembly.PersonDbContext).Assembly)
                 .Build();
 
diff --git a/tests/Database.Updater.Tests/DatabaseUpdaterBuilderTest.cs b/tests/Database.Updater.Tests/DatabaseUpdaterBuilderTest.cs
@@ -13,7 +13,7 @@ public void Constructor_NoApplicationName()
         {
             var action = () => new DatabaseUpdaterBuilder(null);
 
-            action.Should().Throw<ArgumentNullException>()
+            action.Should().ThrowExactly<ArgumentNullException>()
                 .WithParameterName("applicationName")
                 .WithMessage("Value cannot be null. (Parameter 'applicationName')");
         }
@@ -25,9 +25,19 @@ public void Constructor_ApplicationName_EmptyOrWhitespace(string applicationName
         {
             var action = () => new DatabaseUpdaterBuilder(applicationName);
 
-            action.Should().Throw<ArgumentException>()
+            action.Should().ThrowExactly<ArgumentException>()
                 .WithParameterName("applicationName")
                 .WithMessage("The value cannot be an empty string or composed entirely of whitespace. (Parameter 'applicationName')");
         }
+
+        [Fact]
+        public void Build_NoDatabaseProvider()
+        {
+            var builder = new DatabaseUpdaterBuilder("MyApplication");
+
+            builder.Invoking(b => b.Build())
+                .Should().ThrowExactly<InvalidOperationException>()
+                .WithMessage("No database provider has been configured.");
+        }
     }
 }
diff --git a/tests/Database.Updater.Tests/DatabaseUpdaterTest.cs b/tests/Database.Updater.Tests/DatabaseUpdaterTest.cs
@@ -21,6 +21,7 @@ public async Task UpgradeAsync_WithExplicitMigrationsAssembly()
             var database = await server.CreateEmptyDatabaseAsync("DatabaseUpdaterTest_UpgradeAsync_WithExplicitMigrationsAssembly");
 
             var databaseUpdaterBuilder = new DatabaseUpdaterBuilder("MyApplication")
+                .UseSqlServer()
                 .UseMigrationsAssembly(typeof(MigrationsAssembly.Version1).Assembly);
             var databaseUpdater = databaseUpdaterBuilder
                 .Build();
@@ -50,6 +51,7 @@ public async Task UpgradeAsync_WithErrorMigrationsAssembly()
             var database = await server.CreateEmptyDatabaseAsync("DatabaseUpdaterTest_UpgradeAsync_WithErrorMigrationsAssembly");
 
             var databaseUpdaterBuilder = new DatabaseUpdaterBuilder("MyApplication")
+                .UseSqlServer()
                 .UseMigrationsAssembly(typeof(MigrationsErrorAssembly.Version1).Assembly);
             var databaseUpdater = databaseUpdaterBuilder
                 .Build();
@@ -64,6 +66,7 @@ public async Task UpgradeAsync_NoArguments()
         {
             var databaseUpdaterBuilder = new DatabaseUpdaterBuilder("MyApplication");
             var databaseUpdater = databaseUpdaterBuilder
+                .UseSqlServer()
                 .Build();
 
             var result = await databaseUpdater.UpgradeAsync([]);
@@ -78,6 +81,7 @@ public async Task UpgradeAsync_WrongArguments(params string[] args)
         {
             var databaseUpdaterBuilder = new DatabaseUpdaterBuilder("MyApplication");
             var databaseUpdater = databaseUpdaterBuilder
+                .UseSqlServer()
                 .Build();
 
             var result = await databaseUpdater.UpgradeAsync(args);
diff --git a/tests/Database.Updater.Tests/SqlServer/SqlServerDatabaseUpdaterBuilderExtensionsTest.cs b/tests/Database.Updater.Tests/SqlServer/SqlServerDatabaseUpdaterBuilderExtensionsTest.cs
@@ -0,0 +1,23 @@
+﻿//-----------------------------------------------------------------------
+// <copyright file="SqlServerDatabaseUpdaterBuilderExtensionsTest.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Database.Updater.Tests
+{
+    using PosInformatique.Database.Updater.SqlServer;
+
+    public class SqlServerDatabaseUpdaterBuilderExtensionsTest
+    {
+        [Fact]
+        public void Constructor()
+        {
+            var builder = new DatabaseUpdaterBuilder("MyApplication");
+
+            builder.UseSqlServer().Should().BeSameAs(builder);
+
+            builder.GetFieldValue<IDatabaseProvider>("databaseProvider").Should().BeOfType<SqlServerDatabaseProvider>();
+        }
+    }
+}
diff --git a/tests/Database.Updater.Tests/TestTools.cs b/tests/Database.Updater.Tests/TestTools.cs
@@ -0,0 +1,22 @@
+﻿//-----------------------------------------------------------------------
+// <copyright file="TestTools.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Database.Updater.Tests
+{
+    using System.Reflection;
+
+    public static class TestTools
+    {
+        public static T GetFieldValue<T>(this object obj, string fieldName)
+        {
+            var field = obj.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
+
+            var value = field!.GetValue(obj);
+
+            return (T)value!;
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public void Constructor_NoApplicationName()`
`13`	`13`	`{`
`14`	`14`	`var action = () => new DatabaseUpdaterBuilder(null);`
`15`	`15`
`16`		`- action.Should().Throw<ArgumentNullException>()`
	`16`	`+ action.Should().ThrowExactly<ArgumentNullException>()`
`17`	`17`	`.WithParameterName("applicationName")`
`18`	`18`	`.WithMessage("Value cannot be null. (Parameter 'applicationName')");`
`19`	`19`	`}`
`@@ -25,9 +25,19 @@ public void Constructor_ApplicationName_EmptyOrWhitespace(string applicationName`
`25`	`25`	`{`
`26`	`26`	`var action = () => new DatabaseUpdaterBuilder(applicationName);`
`27`	`27`
`28`		`- action.Should().Throw<ArgumentException>()`
	`28`	`+ action.Should().ThrowExactly<ArgumentException>()`
`29`	`29`	`.WithParameterName("applicationName")`
`30`	`30`	`.WithMessage("The value cannot be an empty string or composed entirely of whitespace. (Parameter 'applicationName')");`
`31`	`31`	`}`
	`32`	`+`
	`33`	`+ [Fact]`
	`34`	`+ public void Build_NoDatabaseProvider()`
	`35`	`+ {`
	`36`	`+ var builder = new DatabaseUpdaterBuilder("MyApplication");`
	`37`	`+`
	`38`	`+ builder.Invoking(b => b.Build())`
	`39`	`+ .Should().ThrowExactly<InvalidOperationException>()`
	`40`	`+ .WithMessage("No database provider has been configured.");`
	`41`	`+ }`
`32`	`42`	`}`
`33`	`43`	`}`