[SQL Server] The database must be locked during migrations and tear down.

Author: PawelGerr

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

@@ -0,0 +1,54 @@
+namespace Thinktecture.EntityFrameworkCore.Testing;
+
+/// <summary>
+/// Options used for locking the database during migrations and tear down.
+/// </summary>
+public class SqlServerLockTableOptions
+{
+   /// <summary>
+   /// Indication whether the feature is enabled or not.
+   /// </summary>
+   public bool IsEnabled { get; }
+
+   /// <summary>
+   /// The name of the table.
+   /// Default: '__IntegrationTestIsolation'
+   /// </summary>
+   public string Name { get; set; }
+
+   /// <summary>
+   /// The schema of the table.
+   /// </summary>
+   public string? Schema { get; set; }
+
+   /// <summary>
+   /// Number of retries for creation of the table.
+   /// Default: 10
+   /// </summary>
+   public int MaxNumberOfLockRetries { get; set; }
+
+   /// <summary>
+   /// Min. delay between retries to create the table.
+   /// Default: 50ms
+   /// </summary>
+   public TimeSpan MinRetryDelay { get; set; }
+
+   /// <summary>
+   /// Max. delay between retries to create the table.
+   /// Default: 300ms
+   /// </summary>
+   public TimeSpan MaxRetryDelay { get; set; }
+
+   /// <summary>
+   /// Initializes new instance of <see cref="SqlServerLockTableOptions"/>.
+   /// </summary>
+   /// <param name="isEnabled">Indication whether the feature is enabled or not.</param>
+   public SqlServerLockTableOptions(bool isEnabled)
+   {
+      IsEnabled = isEnabled;
+      Name = "__IntegrationTestIsolation";
+      MaxNumberOfLockRetries = 10;
+      MinRetryDelay = TimeSpan.FromMilliseconds(50);
+      MaxRetryDelay = TimeSpan.FromMilliseconds(200);
+   }
+}

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

@@ -43,14 +43,21 @@ public class SqlServerTestDbContextProvider<T> : SqlServerTestDbContextProvider,
    private readonly Func<DbContextOptions<T>, IDbDefaultSchema, T?>? _contextFactory;
    private readonly TestingLoggingOptions _testingLoggingOptions;
 
+   private readonly bool _lockTableEnabled;
+   private readonly string _lockTableName;
+   private readonly string? _lockTableSchema;
+   private readonly int _maxNumberOfLockRetries;
+   private readonly TimeSpan _minRetryDelay;
+   private readonly TimeSpan _maxRetryDelay;
+   private readonly Random _random;
+
    private Func<DbContextOptions<T>, IDbDefaultSchema, T>? _defaultContextFactory;
    private T? _arrangeDbContext;
    private T? _actDbContext;
    private T? _assertDbContext;
    private IDbContextTransaction? _tx;
    private bool _isAtLeastOneContextCreated;
    private readonly IsolationLevel _sharedTablesIsolationLevel;
-   private readonly IsolationLevel _migrationAndCleanupIsolationLevel;
    private bool _isDisposed;
 
    /// <inheritdoc />
@@ -89,7 +96,6 @@ protected internal SqlServerTestDbContextProvider(SqlServerTestDbContextProvider
       _instanceWideLock = new object();
       Schema = options.Schema ?? throw new ArgumentException($"The '{nameof(options.Schema)}' cannot be null.", nameof(options));
       _sharedTablesIsolationLevel = ValidateIsolationLevel(options.SharedTablesIsolationLevel);
-      _migrationAndCleanupIsolationLevel = options.MigrationAndCleanupIsolationLevel ?? IsolationLevel.Serializable;
       _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));
@@ -99,6 +105,15 @@ protected internal SqlServerTestDbContextProvider(SqlServerTestDbContextProvider
       _contextInitializations = options.ContextInitializations ?? throw new ArgumentException($"The '{nameof(options.ContextInitializations)}' cannot be null.", nameof(options));
       ExecutedCommands = options.ExecutedCommands;
       _contextFactory = options.ContextFactory;
+
+      _random = new Random();
+
+      _lockTableEnabled = options.LockTable.IsEnabled;
+      _lockTableName = options.LockTable.Name;
+      _lockTableSchema = options.LockTable.Schema;
+      _maxNumberOfLockRetries = options.LockTable.MaxNumberOfLockRetries;
+      _minRetryDelay = options.LockTable.MinRetryDelay;
+      _maxRetryDelay = options.LockTable.MaxRetryDelay;
    }
 
    private static IsolationLevel ValidateIsolationLevel(IsolationLevel? isolationLevel)
@@ -231,7 +246,57 @@ protected virtual IDbContextTransaction BeginTransaction(T ctx)
    {
       ArgumentNullException.ThrowIfNull(ctx);
 
-      return ctx.Database.BeginTransaction(_migrationAndCleanupIsolationLevel);
+      if (!_lockTableEnabled)
+         return ctx.Database.BeginTransaction(IsolationLevel.Serializable);
+
+      var sqlGenerationHelper = ctx.GetService<ISqlGenerationHelper>();
+      var lockTableName = sqlGenerationHelper.DelimitIdentifier(_lockTableName, _lockTableSchema);
+
+      CreateTestIsolationTable(ctx, lockTableName);
+
+      var tx = ctx.Database.BeginTransaction(IsolationLevel.Serializable);
+
+      try
+      {
+         LockDatabase(ctx, lockTableName);
+      }
+      catch (Exception)
+      {
+         tx.Dispose();
+         throw;
+      }
+
+      return tx;
+   }
+
+   private void CreateTestIsolationTable(T ctx, string lockTableName)
+   {
+      var createTableSql = $@"
+IF(OBJECT_ID('{lockTableName}') IS NULL)
+	CREATE TABLE {lockTableName}(Id INT NOT NULL)";
+
+      for (var i = 0;; i++)
+      {
+         try
+         {
+            ctx.Database.ExecuteSqlRaw(createTableSql);
+            return;
+         }
+         catch (Exception)
+         {
+            if (i > _maxNumberOfLockRetries)
+               throw;
+
+            var delay = new TimeSpan(_random.NextInt64(_minRetryDelay.Ticks, _maxRetryDelay.Ticks));
+            Task.Delay(delay).GetAwaiter().GetResult();
+         }
+      }
+   }
+
+   private static void LockDatabase(T ctx, string lockTableName)
+   {
+      var selectSql = $"SELECT * FROM {lockTableName} WITH (HOLDLOCK, UPDLOCK)";
+      ctx.Database.ExecuteSqlRaw(selectSql);
    }
 
    /// <summary>
@@ -353,7 +418,21 @@ private async Task DisposeContextsAndRollbackMigrationsAsync(CancellationToken c
          // Create a new ctx as a last resort to rollback migrations and clean up the database
          await using var ctx = _actDbContext ?? _arrangeDbContext ?? _assertDbContext ?? CreateDbContext(_masterDbContextOptions, new DbDefaultSchema(Schema));
 
-         await _isolationOptions.CleanupAsync(ctx, Schema, cancellationToken);
+         IDbContextTransaction? migrationTx = null;
+
+         if (ctx.Database.CurrentTransaction is null)
+            migrationTx = BeginMigrationAndCleanupTransaction(ctx);
+
+         try
+         {
+            await _isolationOptions.CleanupAsync(ctx, Schema, cancellationToken);
+
+            await (migrationTx?.CommitAsync(cancellationToken) ?? Task.CompletedTask);
+         }
+         finally
+         {
+            await (migrationTx?.DisposeAsync() ?? ValueTask.CompletedTask);
+         }
       }
 
       await (_arrangeDbContext?.DisposeAsync() ?? ValueTask.CompletedTask);

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

@@ -27,7 +27,7 @@ public class SqlServerTestDbContextProviderBuilder<T> : TestDbContextProviderBui
    private bool _useThinktectureSqlServerMigrationsSqlGenerator = true;
    private string? _sharedTablesSchema;
    private IsolationLevel? _sharedTablesIsolationLevel;
-   private IsolationLevel? _migrationAndCleanupIsolationLevel;
+   private SqlServerLockTableOptions? _lockTable;
    private Func<DbContextOptions<T>, IDbDefaultSchema, T?>? _contextFactory;
    private Func<SqlServerTestDbContextProviderOptions<T>, SqlServerTestDbContextProvider<T>?>? _providerFactory;
 
@@ -57,27 +57,58 @@ public SqlServerTestDbContextProviderBuilder(string connectionString, ITestIsola
    }
 
    /// <summary>
-   /// Specifies the isolation level to use with shared tables.
-   /// Default is <see cref="IsolationLevel.ReadCommitted"/>.
+   /// Disables locking of the database during migrations and tear down.
    /// </summary>
-   /// <param name="sharedTablesIsolationLevel">Isolation level to use.</param>
    /// <returns>Current builder for chaining</returns>
-   public SqlServerTestDbContextProviderBuilder<T> UseSharedTablesIsolationLevel(IsolationLevel sharedTablesIsolationLevel)
+   public SqlServerTestDbContextProviderBuilder<T> DisableLockingDuringDDL()
    {
-      _sharedTablesIsolationLevel = sharedTablesIsolationLevel;
+      _lockTable = new SqlServerLockTableOptions(false);
+
+      return this;
+   }
+
+   /// <summary>
+   /// Enables locking of the database during migrations and tear down.
+   /// This feature is enabled by default.
+   /// </summary>
+   /// <param name="tableName">The name of the lock table.</param>
+   /// <param name="schema">The schema of the lock table.</param>
+   /// <param name="maxNumberOfLockRetries">Number of retries for creation of the lock table.</param>
+   /// <param name="minRetryDelay">Minimum delay between retries.</param>
+   /// <param name="maxRetryDelay">Maximum delay between retries.</param>
+   /// <returns>Current builder for chaining</returns>
+   public SqlServerTestDbContextProviderBuilder<T> UseLockingDuringDDL(
+      string tableName,
+      string? schema,
+      int maxNumberOfLockRetries = 10,
+      TimeSpan? minRetryDelay = null,
+      TimeSpan? maxRetryDelay = null)
+   {
+      _lockTable = new SqlServerLockTableOptions(true)
+                   {
+                      Name = tableName,
+                      Schema = schema,
+                      MaxNumberOfLockRetries = maxNumberOfLockRetries
+                   };
+
+      if (minRetryDelay.HasValue)
+         _lockTable.MinRetryDelay = minRetryDelay.Value;
+
+      if (maxRetryDelay.HasValue)
+         _lockTable.MaxRetryDelay = maxRetryDelay.Value;
 
       return this;
    }
 
    /// <summary>
-   /// Specifies the isolation level to use when migrating and cleaning up the database.
-   /// Default is <see cref="IsolationLevel.Serializable"/>.
+   /// Specifies the isolation level to use with shared tables.
+   /// Default is <see cref="IsolationLevel.ReadCommitted"/>.
    /// </summary>
-   /// <param name="migrationAndCleanupIsolationLevel">Isolation level to use.</param>
+   /// <param name="sharedTablesIsolationLevel">Isolation level to use.</param>
    /// <returns>Current builder for chaining</returns>
-   public SqlServerTestDbContextProviderBuilder<T> UseMigrationAndCleanupIsolationLevel(IsolationLevel migrationAndCleanupIsolationLevel)
+   public SqlServerTestDbContextProviderBuilder<T> UseSharedTablesIsolationLevel(IsolationLevel sharedTablesIsolationLevel)
    {
-      _migrationAndCleanupIsolationLevel = migrationAndCleanupIsolationLevel;
+      _sharedTablesIsolationLevel = sharedTablesIsolationLevel;
 
       return this;
    }
@@ -372,7 +403,7 @@ public SqlServerTestDbContextProvider<T> Build()
                           ContextFactory = _contextFactory,
                           ExecutedCommands = state.CommandCapturingInterceptor?.Commands,
                           SharedTablesIsolationLevel = _sharedTablesIsolationLevel,
-                          MigrationAndCleanupIsolationLevel = _migrationAndCleanupIsolationLevel
+                          LockTable = _lockTable
                        };
 
          return _providerFactory?.Invoke(options) ?? new SqlServerTestDbContextProvider<T>(options);

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

@@ -1,5 +1,6 @@
 using System.Data;
 using System.Data.Common;
+using System.Diagnostics.CodeAnalysis;
 using Thinktecture.Logging;
 
 namespace Thinktecture.EntityFrameworkCore.Testing;
@@ -49,11 +50,17 @@ public ITestIsolationOptions IsolationOptions
    /// </summary>
    public IsolationLevel? SharedTablesIsolationLevel { get; set; }
 
+   private SqlServerLockTableOptions? _lockTable;
+
    /// <summary>
-   /// Isolation level to use when migrating and cleaning up the database.
-   /// Default is <see cref="IsolationLevel.Serializable"/>.
+   /// Options used for locking the database during migrations and tear down.
    /// </summary>
-   public IsolationLevel? MigrationAndCleanupIsolationLevel { get; set; }
+   [AllowNull]
+   public SqlServerLockTableOptions LockTable
+   {
+      get => _lockTable ??= new SqlServerLockTableOptions(true);
+      set => _lockTable = value;
+   }
 
    /// <summary>
    /// Initializes new instance of <see cref="SqlServerTestDbContextProviderOptions{T}"/>.