Check whether database provider is registered before registration of custom extensions

Author: PawelGerr

src/Thinktecture.EntityFrameworkCore.Relational/Extensions/RelationalDbContextOptionsBuilderExtensions.cs

@@ -172,18 +172,23 @@ public static TExtension TryAddExtension<TExtension>(this DbContextOptionsBuilde
    /// </summary>
    /// <param name="optionsBuilder">Options builder.</param>
    /// <param name="callback">Callback that updates the extension.</param>
+   /// <param name="ensureDatabaseProviderRegistered">Indication whether to check whether a database provider is registered already.</param>
    /// <typeparam name="TExtension">Type of the extension.</typeparam>
    /// <exception cref="ArgumentNullException">
    /// <paramref name="optionsBuilder"/> is null
    /// - or
    /// <paramref name="callback"/> is null.
    /// </exception>
+   /// <exception cref="InvalidOperationException">
+   /// If <paramref name="ensureDatabaseProviderRegistered"/> is <c>true</c> and the database is not registered yet.
+   /// </exception>
    public static TExtension AddOrUpdateExtension<TExtension>(
       this DbContextOptionsBuilder optionsBuilder,
-      Action<TExtension> callback)
+      Action<TExtension> callback,
+      bool ensureDatabaseProviderRegistered = true)
       where TExtension : class, IDbContextOptionsExtension, new()
    {
-      return AddOrUpdateExtension(optionsBuilder, callback, () => new TExtension());
+      return AddOrUpdateExtension(optionsBuilder, callback, () => new TExtension(), ensureDatabaseProviderRegistered);
    }
 
    /// <summary>
@@ -192,23 +197,31 @@ public static TExtension AddOrUpdateExtension<TExtension>(
    /// <param name="optionsBuilder">Options builder.</param>
    /// <param name="callback">Callback that updates the extension.</param>
    /// <param name="extensionFactory">Factory for creation of new instances of <typeparamref name="TExtension"/>.</param>
+   /// <param name="ensureDatabaseProviderRegistered">Indication whether to check whether a database provider is registered already.</param>
    /// <typeparam name="TExtension">Type of the extension.</typeparam>
    /// <exception cref="ArgumentNullException">
    /// <paramref name="optionsBuilder"/> is null
    /// - or
    /// <paramref name="callback"/> is null.
    /// </exception>
+   /// <exception cref="InvalidOperationException">
+   /// If <paramref name="ensureDatabaseProviderRegistered"/> is <c>true</c> and the database is not registered yet.
+   /// </exception>
    public static TExtension AddOrUpdateExtension<TExtension>(
       this DbContextOptionsBuilder optionsBuilder,
       Action<TExtension> callback,
-      Func<TExtension> extensionFactory
+      Func<TExtension> extensionFactory,
+      bool ensureDatabaseProviderRegistered = true
    )
       where TExtension : class, IDbContextOptionsExtension
    {
       ArgumentNullException.ThrowIfNull(optionsBuilder);
       ArgumentNullException.ThrowIfNull(callback);
       ArgumentNullException.ThrowIfNull(extensionFactory);
 
+      if (ensureDatabaseProviderRegistered && !optionsBuilder.Options.Extensions.Any(e => e.Info.IsDatabaseProvider))
+         throw new InvalidOperationException("Please register the database provider first (via 'UseSqlServer' or 'UseSqlite' etc).");
+
       var extension = optionsBuilder.Options.FindExtension<TExtension>() ?? extensionFactory();
 
       callback(extension);

tests/Thinktecture.EntityFrameworkCore.Relational.Tests/Extensions/DbContextOptionsBuilderTests/AddOrUpdateExtension.cs

@@ -0,0 +1,36 @@
+using Thinktecture.EntityFrameworkCore.Infrastructure;
+using Thinktecture.TestDatabaseContext;
+
+namespace Thinktecture.Extensions.DbContextOptionsBuilderTests;
+
+public class AddOrUpdateExtension
+{
+   [Fact]
+   public void Should_throw_if_database_provider_not_registered()
+   {
+      new DbContextOptionsBuilder<DbContextWithoutSchema>()
+         .Invoking(b => b.AddOrUpdateExtension<RelationalDbContextOptionsExtension>(_ =>
+                                                                                    {
+                                                                                    }))
+         .Should().Throw<InvalidOperationException>().WithMessage("Please register the database provider first (via 'UseSqlServer' or 'UseSqlite' etc).");
+   }
+
+   [Fact]
+   public void Should_not_throw_if_database_provider_is_registered_already()
+   {
+      new DbContextOptionsBuilder<DbContextWithoutSchema>()
+         .UseSqlite("DataSource=:memory:")
+         .Invoking(b => b.AddOrUpdateExtension<RelationalDbContextOptionsExtension>(_ =>
+                                                                                    {
+                                                                                    }))
+         .Should().NotThrow();
+   }
+
+   [Fact]
+   public void Should_not_throw_if_called_inside_database_provider_specific_callback()
+   {
+      new DbContextOptionsBuilder<DbContextWithoutSchema>()
+         .UseSqlite("DataSource=:memory:",
+                    sqliteBuilder => sqliteBuilder.Invoking(b => b.AddBulkOperationSupport()).Should().NotThrow());
+   }
+}