Implemented SqliteTestDbContextProviderFactory that creates new providers with operate on a clone of previously migrated database.

Author: PawelGerr

src/Thinktecture.EntityFrameworkCore.SqlServer.Testing/EntityFrameworkCore/Testing/SqlServerTestDbContextProvider.cs

@@ -98,8 +98,8 @@ protected internal SqlServerTestDbContextProvider(SqlServerTestDbContextProvider
       _sharedTablesIsolationLevel = ValidateIsolationLevel(options.SharedTablesIsolationLevel);
       _isolationOptions = options.IsolationOptions;
       _masterConnection = options.MasterConnection ?? throw new ArgumentException($"The '{nameof(options.MasterConnection)}' cannot be null.", nameof(options));
-      _masterDbContextOptions = options.MasterDbContextOptions ?? throw new ArgumentException($"The '{nameof(options.MasterDbContextOptions)}' cannot be null.", nameof(options));
-      _dbContextOptions = options.DbContextOptions ?? throw new ArgumentException($"The '{nameof(options.DbContextOptions)}' cannot be null.", nameof(options));
+      _masterDbContextOptions = options.MasterDbContextOptionsBuilder.Options ?? throw new ArgumentException($"The '{nameof(options.MasterDbContextOptionsBuilder)}' cannot be null.", nameof(options));
+      _dbContextOptions = options.DbContextOptionsBuilder.Options ?? throw new ArgumentException($"The '{nameof(options.DbContextOptionsBuilder)}' cannot be null.", nameof(options));
       _migrationExecutionStrategy = options.MigrationExecutionStrategy ?? throw new ArgumentException($"The '{nameof(options.MigrationExecutionStrategy)}' cannot be null.", nameof(options));
       _testingLoggingOptions = options.TestingLoggingOptions ?? throw new ArgumentException($"The '{nameof(options.TestingLoggingOptions)}' cannot be null.", nameof(options));
       _contextInitializations = options.ContextInitializations ?? throw new ArgumentException($"The '{nameof(options.ContextInitializations)}' cannot be null.", nameof(options));

src/Thinktecture.EntityFrameworkCore.SqlServer.Testing/EntityFrameworkCore/Testing/SqlServerTestDbContextProviderBuilder.cs

@@ -391,13 +391,13 @@ public SqlServerTestDbContextProvider<T> Build()
       {
          var loggingOptions = CreateLoggingOptions();
          var state = new TestDbContextProviderBuilderState(loggingOptions);
-         var masterDbContextOptions = CreateOptionsBuilder(state, masterConnection, schema).Options;
-         var dbContextOptions = CreateOptionsBuilder(state, null, schema).Options;
+         var masterDbContextOptionsBuilder = CreateOptionsBuilder(state, masterConnection, schema);
+         var dbContextOptionsBuilder = CreateOptionsBuilder(state, null, schema);
 
          var options = new SqlServerTestDbContextProviderOptions<T>(masterConnection,
                                                                     state.MigrationExecutionStrategy ?? IMigrationExecutionStrategy.Migrations,
-                                                                    masterDbContextOptions,
-                                                                    dbContextOptions,
+                                                                    masterDbContextOptionsBuilder,
+                                                                    dbContextOptionsBuilder,
                                                                     loggingOptions,
                                                                     _ctxInitializations.ToList(),
                                                                     schema)

src/Thinktecture.EntityFrameworkCore.SqlServer.Testing/EntityFrameworkCore/Testing/SqlServerTestDbContextProviderOptions.cs

@@ -1,6 +1,6 @@
 using System.Data;
-using System.Data.Common;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.Data.SqlClient;
 using Thinktecture.Logging;
 
 namespace Thinktecture.EntityFrameworkCore.Testing;
@@ -13,25 +13,19 @@ public class SqlServerTestDbContextProviderOptions<T> : TestDbContextProviderOpt
    where T : DbContext
 {
    /// <summary>
-   /// Indication whether the current <see cref="SqlServerTestDbContextProvider{T}"/> is using its own tables with a new schema
-   /// or shares the tables with others.
+   /// Master database connection.
    /// </summary>
-   [Obsolete($"Use '{nameof(IsolationOptions)}' instead.")]
-   public bool IsUsingSharedTables
-   {
-      get => IsolationOptions == ITestIsolationOptions.SharedTablesAmbientTransaction;
-      set => IsolationOptions = value ? ITestIsolationOptions.SharedTablesAmbientTransaction : ITestIsolationOptions.RollbackMigrationsAndCleanup;
-   }
+   public new SqlConnection MasterConnection => (SqlConnection)base.MasterConnection;
 
-   private ITestIsolationOptions? _isolationOptions;
+   private readonly ITestIsolationOptions? _isolationOptions;
 
    /// <summary>
    /// Test isolation behavior.
    /// </summary>
    public ITestIsolationOptions IsolationOptions
    {
       get => _isolationOptions ?? ITestIsolationOptions.SharedTablesAmbientTransaction;
-      set => _isolationOptions = value;
+      init => _isolationOptions = value;
    }
 
    /// <summary>
@@ -42,13 +36,13 @@ public ITestIsolationOptions IsolationOptions
    /// <summary>
    /// A factory method for creation of contexts of type <typeparamref name="T"/>.
    /// </summary>
-   public Func<DbContextOptions<T>, IDbDefaultSchema?, T?>? ContextFactory { get; set; }
+   public Func<DbContextOptions<T>, IDbDefaultSchema?, T?>? ContextFactory { get; init; }
 
    /// <summary>
    /// Isolation level to be used with shared tables.
    /// Default is <see cref="IsolationLevel.ReadCommitted"/>.
    /// </summary>
-   public IsolationLevel? SharedTablesIsolationLevel { get; set; }
+   public IsolationLevel? SharedTablesIsolationLevel { get; init; }
 
    private SqlServerLockTableOptions? _lockTable;
 
@@ -59,21 +53,21 @@ public ITestIsolationOptions IsolationOptions
    public SqlServerLockTableOptions LockTable
    {
       get => _lockTable ??= new SqlServerLockTableOptions(true);
-      set => _lockTable = value;
+      init => _lockTable = value;
    }
 
    /// <summary>
    /// Initializes new instance of <see cref="SqlServerTestDbContextProviderOptions{T}"/>.
    /// </summary>
    public SqlServerTestDbContextProviderOptions(
-      DbConnection masterConnection,
+      SqlConnection masterConnection,
       IMigrationExecutionStrategy migrationExecutionStrategy,
-      DbContextOptions<T> masterDbContextOptions,
-      DbContextOptions<T> dbContextOptions,
+      DbContextOptionsBuilder<T> masterDbContextOptionsBuilder,
+      DbContextOptionsBuilder<T> dbContextOptionsBuilder,
       TestingLoggingOptions testingLoggingOptions,
       IReadOnlyList<Action<T>> contextInitializations,
       string? schema)
-      : base(masterConnection, migrationExecutionStrategy, masterDbContextOptions, dbContextOptions, testingLoggingOptions, contextInitializations)
+      : base(masterConnection, migrationExecutionStrategy, masterDbContextOptionsBuilder, dbContextOptionsBuilder, testingLoggingOptions, contextInitializations)
    {
       Schema = schema;
    }

src/Thinktecture.EntityFrameworkCore.Sqlite.Testing/EntityFrameworkCore/Testing/SqlServerTestDbContextProviderOptions.cs

@@ -1,38 +1,43 @@
-using System.Data.Common;
-using Thinktecture.Logging;
-
-namespace Thinktecture.EntityFrameworkCore.Testing;
-
-/// <summary>
-/// Options for the <see cref="SqliteTestDbContextProvider{T}"/>.
-/// </summary>
-/// <typeparam name="T"></typeparam>
-public class SqliteTestDbContextProviderOptions<T> : TestDbContextProviderOptions<T>
-   where T : DbContext
-{
-   /// <summary>
-   /// A factory method for creation of contexts of type <typeparamref name="T"/>.
-   /// </summary>
-   public Func<DbContextOptions<T>, T?>? ContextFactory { get; set; }
-
-   /// <summary>
-   /// The connection string.
-   /// </summary>
-   public string ConnectionString { get; set; }
-
-   /// <summary>
-   /// Initializes new instance of <see cref="SqliteTestDbContextProviderOptions{T}"/>
-   /// </summary>
-   public SqliteTestDbContextProviderOptions(
-      DbConnection masterConnection,
-      IMigrationExecutionStrategy migrationExecutionStrategy,
-      DbContextOptions<T> masterDbContextOptions,
-      DbContextOptions<T> dbContextOptions,
-      TestingLoggingOptions testingLoggingOptions,
-      IReadOnlyList<Action<T>> contextInitializations,
-      string connectionString)
-      : base(masterConnection, migrationExecutionStrategy, masterDbContextOptions, dbContextOptions, testingLoggingOptions, contextInitializations)
-   {
-      ConnectionString = connectionString;
-   }
-}
+using Microsoft.Data.Sqlite;
+using Thinktecture.Logging;
+
+namespace Thinktecture.EntityFrameworkCore.Testing;
+
+/// <summary>
+/// Options for the <see cref="SqliteTestDbContextProvider{T}"/>.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public class SqliteTestDbContextProviderOptions<T> : TestDbContextProviderOptions<T>
+   where T : DbContext
+{
+   /// <summary>
+   /// Master database connection.
+   /// </summary>
+   public new SqliteConnection MasterConnection => (SqliteConnection)base.MasterConnection;
+
+   /// <summary>
+   /// Indication whether the master connection is externally owned.
+   /// </summary>
+   public bool IsExternallyOwnedMasterConnection { get; }
+
+   /// <summary>
+   /// A factory method for creation of contexts of type <typeparamref name="T"/>.
+   /// </summary>
+   public Func<DbContextOptions<T>, T?>? ContextFactory { get; init; }
+
+   /// <summary>
+   /// Initializes new instance of <see cref="SqliteTestDbContextProviderOptions{T}"/>
+   /// </summary>
+   public SqliteTestDbContextProviderOptions(
+      SqliteConnection masterConnection,
+      bool isExternallyOwnedMasterConnection,
+      IMigrationExecutionStrategy migrationExecutionStrategy,
+      DbContextOptionsBuilder<T> masterDbContextOptionsBuilder,
+      DbContextOptionsBuilder<T> dbContextOptionsBuilder,
+      TestingLoggingOptions testingLoggingOptions,
+      IReadOnlyList<Action<T>> contextInitializations)
+      : base(masterConnection, migrationExecutionStrategy, masterDbContextOptionsBuilder, dbContextOptionsBuilder, testingLoggingOptions, contextInitializations)
+   {
+      IsExternallyOwnedMasterConnection = isExternallyOwnedMasterConnection;
+   }
+}

src/Thinktecture.EntityFrameworkCore.Sqlite.Testing/EntityFrameworkCore/Testing/SqliteTestDbContextProvider.cs

@@ -1,4 +1,5 @@
-using System.Data.Common;
+using System.Data;
+using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Thinktecture.Logging;
 
@@ -11,13 +12,12 @@ namespace Thinktecture.EntityFrameworkCore.Testing;
 public class SqliteTestDbContextProvider<T> : ITestDbContextProvider<T>
    where T : DbContext
 {
-   // ReSharper disable once StaticMemberInGenericType because the lock are all for the same database context.
-   private static readonly object _lock = new();
+   private readonly object _lock = new();
 
    private readonly DbContextOptions<T> _masterDbContextOptions;
    private readonly DbContextOptions<T> _dbContextOptions;
    private readonly IMigrationExecutionStrategy _migrationExecutionStrategy;
-   private readonly DbConnection _masterConnection;
+   private readonly bool _isExternallyOwnedMasterConnection;
    private readonly IReadOnlyList<Action<T>> _contextInitializations;
    private readonly Func<DbContextOptions<T>, T?>? _contextFactory;
 
@@ -28,6 +28,11 @@ public class SqliteTestDbContextProvider<T> : ITestDbContextProvider<T>
    private readonly TestingLoggingOptions _testingLoggingOptions;
    private bool _isDisposed;
 
+   /// <summary>
+   /// A database connection which kept open during the test, so the in-memory database is not deleted.
+   /// </summary>
+   public SqliteConnection MasterConnection { get; }
+
    /// <inheritdoc />
    public T ArrangeDbContext => _arrangeDbContext ??= CreateDbContext(true);
 
@@ -50,7 +55,7 @@ public class SqliteTestDbContextProvider<T> : ITestDbContextProvider<T>
    /// <summary>
    /// The connection string.
    /// </summary>
-   public string ConnectionString { get; }
+   public string ConnectionString => MasterConnection.ConnectionString;
 
    /// <summary>
    /// Initializes a new instance of <see cref="SqliteTestDbContextProvider{T}"/>
@@ -60,10 +65,10 @@ protected internal SqliteTestDbContextProvider(SqliteTestDbContextProviderOption
    {
       ArgumentNullException.ThrowIfNull(options);
 
-      ConnectionString = options.ConnectionString ?? throw new ArgumentException($"The '{nameof(options.ConnectionString)}' cannot be null.", nameof(options));
-      _masterConnection = options.MasterConnection ?? throw new ArgumentException($"The '{nameof(options.MasterConnection)}' cannot be null.", nameof(options));
-      _masterDbContextOptions = options.MasterDbContextOptions ?? throw new ArgumentException($"The '{nameof(options.MasterDbContextOptions)}' cannot be null.", nameof(options));
-      _dbContextOptions = options.DbContextOptions ?? throw new ArgumentException($"The '{nameof(options.DbContextOptions)}' cannot be null.", nameof(options));
+      MasterConnection = options.MasterConnection ?? throw new ArgumentException($"The '{nameof(options.MasterConnection)}' cannot be null.", nameof(options));
+      _isExternallyOwnedMasterConnection = options.IsExternallyOwnedMasterConnection;
+      _masterDbContextOptions = options.MasterDbContextOptionsBuilder.Options ?? throw new ArgumentException($"The '{nameof(options.MasterDbContextOptionsBuilder)}' cannot be null.", nameof(options));
+      _dbContextOptions = options.DbContextOptionsBuilder.Options ?? throw new ArgumentException($"The '{nameof(options.DbContextOptionsBuilder)}' cannot be null.", nameof(options));
       _migrationExecutionStrategy = options.MigrationExecutionStrategy ?? throw new ArgumentException($"The '{nameof(options.MigrationExecutionStrategy)}' cannot be null.", nameof(options));
       _testingLoggingOptions = options.TestingLoggingOptions ?? throw new ArgumentException($"The '{nameof(options.TestingLoggingOptions)}' cannot be null.", nameof(options));
       _contextInitializations = options.ContextInitializations ?? throw new ArgumentException($"The '{nameof(options.ContextInitializations)}' cannot be null.", nameof(options));
@@ -98,7 +103,14 @@ public T CreateDbContext(bool useMasterConnection)
 
       if (isFirstCtx)
       {
-         _masterConnection.Open();
+         if (MasterConnection.State != ConnectionState.Open)
+         {
+            if (_isExternallyOwnedMasterConnection)
+               throw new InvalidOperationException("Externally owned connections must be opened by the owner.");
+
+            MasterConnection.Open();
+         }
+
          RunMigrations(ctx);
       }
 
@@ -202,7 +214,9 @@ protected virtual async ValueTask DisposeAsync(bool disposing)
          _isAtLeastOneContextCreated = false;
       }
 
-      await _masterConnection.DisposeAsync();
+      if (!_isExternallyOwnedMasterConnection)
+         await MasterConnection.DisposeAsync();
+
       _testingLoggingOptions.Dispose();
    }