SqlServerTestDbContextProviderBuilder doesn't set the default schema "tests" by default anymore

Author: PawelGerr

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

@@ -1,5 +1,7 @@
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Data.SqlClient;
 using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.Storage;
 
@@ -46,7 +48,7 @@ public interface ITestIsolationOptions
    /// <param name="cleanup">Callback that performs the actual cleanup.</param>
    /// <typeparam name="T">Type of the <see cref="DbContext"/></typeparam>
    /// <returns></returns>
-   public static ITestIsolationOptions Custom<T>(bool needsUniqueSchema, Func<T, string, CancellationToken, Task> cleanup)
+   public static ITestIsolationOptions Custom<T>(bool needsUniqueSchema, Func<T, string?, CancellationToken, Task> cleanup)
       where T : DbContext
    {
       return new CustomCleanup<T>(needsUniqueSchema, cleanup);
@@ -70,15 +72,15 @@ public static ITestIsolationOptions Custom<T>(bool needsUniqueSchema, Func<T, st
    /// <summary>
    /// Cleanup of the database.
    /// </summary>
-   ValueTask CleanupAsync(DbContext dbContext, string schema, CancellationToken cancellationToken);
+   ValueTask CleanupAsync(DbContext dbContext, string? schema, CancellationToken cancellationToken);
 
    private class NoIsolation : ITestIsolationOptions
    {
       public bool NeedsAmbientTransaction => false;
       public bool NeedsUniqueSchema => false;
       public bool NeedsCleanup => false;
 
-      public ValueTask CleanupAsync(DbContext dbContext, string schema, CancellationToken cancellationToken)
+      public ValueTask CleanupAsync(DbContext dbContext, string? schema, CancellationToken cancellationToken)
       {
          return ValueTask.CompletedTask;
       }
@@ -90,7 +92,7 @@ private class ShareTablesIsolation : ITestIsolationOptions
       public bool NeedsUniqueSchema => false;
       public bool NeedsCleanup => false;
 
-      public ValueTask CleanupAsync(DbContext dbContext, string schema, CancellationToken cancellationToken)
+      public ValueTask CleanupAsync(DbContext dbContext, string? schema, CancellationToken cancellationToken)
       {
          return ValueTask.CompletedTask;
       }
@@ -102,7 +104,7 @@ private class RollbackMigrationsAndCleanupDatabase : ITestIsolationOptions
       public bool NeedsUniqueSchema => true;
       public bool NeedsCleanup => true;
 
-      public async ValueTask CleanupAsync(DbContext dbContext, string schema, CancellationToken cancellationToken)
+      public async ValueTask CleanupAsync(DbContext dbContext, string? schema, CancellationToken cancellationToken)
       {
          await RollbackMigrationsAsync(dbContext, cancellationToken);
          await DeleteDatabaseObjectsAsync(dbContext, schema, cancellationToken);
@@ -115,7 +117,7 @@ private class CleanupDatabase : ITestIsolationOptions
       public bool NeedsUniqueSchema => true;
       public bool NeedsCleanup => true;
 
-      public async ValueTask CleanupAsync(DbContext dbContext, string schema, CancellationToken cancellationToken)
+      public async ValueTask CleanupAsync(DbContext dbContext, string? schema, CancellationToken cancellationToken)
       {
          await DeleteDatabaseObjectsAsync(dbContext, schema, cancellationToken);
       }
@@ -124,33 +126,34 @@ public async ValueTask CleanupAsync(DbContext dbContext, string schema, Cancella
    private class CustomCleanup<T> : ITestIsolationOptions
       where T : DbContext
    {
-      private readonly Func<T, string, CancellationToken, Task> _cleanup;
+      private readonly Func<T, string?, CancellationToken, Task> _cleanup;
 
       public bool NeedsAmbientTransaction => false;
       public bool NeedsUniqueSchema { get; }
       public bool NeedsCleanup => true;
 
-      public CustomCleanup(bool needsUniqueSchema, Func<T, string, CancellationToken, Task> cleanup)
+      public CustomCleanup(bool needsUniqueSchema, Func<T, string?, CancellationToken, Task> cleanup)
       {
          NeedsUniqueSchema = needsUniqueSchema;
          _cleanup = cleanup;
       }
 
-      public async ValueTask CleanupAsync(DbContext dbContext, string schema, CancellationToken cancellationToken)
+      public async ValueTask CleanupAsync(DbContext dbContext, string? schema, CancellationToken cancellationToken)
       {
          await _cleanup((T)dbContext, schema, cancellationToken);
       }
    }
 
+   [SuppressMessage("Usage", "EF1001:Internal EF Core API usage.")]
    private class TruncateAllTables : ITestIsolationOptions
    {
       public bool NeedsAmbientTransaction => false;
       public bool NeedsUniqueSchema => false;
       public bool NeedsCleanup => true;
 
-      public async ValueTask CleanupAsync(DbContext dbContext, string schema, CancellationToken cancellationToken)
+      public async ValueTask CleanupAsync(DbContext dbContext, string? schema, CancellationToken cancellationToken)
       {
-         foreach (var entityType in dbContext.Model.GetEntityTypes())
+         foreach (var entityType in dbContext.Model.GetEntityTypesInHierarchicalOrder().Reverse())
          {
             if (entityType.GetTableName() is not null)
                await dbContext.TruncateTableAsync(entityType.ClrType, cancellationToken);
@@ -171,15 +174,17 @@ protected static async Task RollbackMigrationsAsync(DbContext dbContext, Cancell
    /// <summary>
    /// Deletes database objects (like tables) with provided <paramref name="schema"/>.
    /// </summary>
-   protected static async Task DeleteDatabaseObjectsAsync(DbContext ctx, string schema, CancellationToken cancellationToken)
+   protected static async Task DeleteDatabaseObjectsAsync(DbContext ctx, string? schema, CancellationToken cancellationToken)
    {
       ArgumentNullException.ThrowIfNull(ctx);
-      ArgumentNullException.ThrowIfNull(schema);
 
-      var sqlHelper = ctx.GetService<ISqlGenerationHelper>();
+      if (schema is not null)
+      {
+         var sqlHelper = ctx.GetService<ISqlGenerationHelper>();
 
-      await ctx.Database.ExecuteSqlRawAsync(GetSqlForCleanup(), new object[] { new SqlParameter("@schema", schema) }, cancellationToken);
-      await ctx.Database.ExecuteSqlRawAsync(GetDropSchemaSql(sqlHelper, schema), cancellationToken);
+         await ctx.Database.ExecuteSqlRawAsync(GetSqlForCleanup(), new object[] { new SqlParameter("@schema", schema) }, cancellationToken);
+         await ctx.Database.ExecuteSqlRawAsync(GetDropSchemaSql(sqlHelper, schema), cancellationToken);
+      }
    }
 
    private static string GetSqlForCleanup()

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

@@ -40,7 +40,7 @@ public class SqlServerTestDbContextProvider<T> : SqlServerTestDbContextProvider,
    private readonly IMigrationExecutionStrategy _migrationExecutionStrategy;
    private readonly DbConnection _masterConnection;
    private readonly IReadOnlyList<Action<T>> _contextInitializations;
-   private readonly Func<DbContextOptions<T>, IDbDefaultSchema, T?>? _contextFactory;
+   private readonly Func<DbContextOptions<T>, IDbDefaultSchema?, T?>? _contextFactory;
    private readonly TestingLoggingOptions _testingLoggingOptions;
 
    private readonly bool _lockTableEnabled;
@@ -51,7 +51,7 @@ public class SqlServerTestDbContextProvider<T> : SqlServerTestDbContextProvider,
    private readonly TimeSpan _maxRetryDelay;
    private readonly Random _random;
 
-   private Func<DbContextOptions<T>, IDbDefaultSchema, T>? _defaultContextFactory;
+   private Func<DbContextOptions<T>, IDbDefaultSchema?, T>? _defaultContextFactory;
    private T? _arrangeDbContext;
    private T? _actDbContext;
    private T? _assertDbContext;
@@ -70,10 +70,10 @@ public class SqlServerTestDbContextProvider<T> : SqlServerTestDbContextProvider,
    public T AssertDbContext => _assertDbContext ??= CreateDbContext(true);
 
    /// <summary>
-   /// Database schema to use.
+   /// Default database schema to use.
    /// </summary>
    // ReSharper disable once MemberCanBePrivate.Global
-   public string Schema { get; }
+   public string? Schema { get; }
 
    /// <summary>
    /// Contains executed commands if this feature was activated.
@@ -94,7 +94,7 @@ protected internal SqlServerTestDbContextProvider(SqlServerTestDbContextProvider
       ArgumentNullException.ThrowIfNull(options);
 
       _instanceWideLock = new object();
-      Schema = options.Schema ?? throw new ArgumentException($"The '{nameof(options.Schema)}' cannot be null.", nameof(options));
+      Schema = options.Schema;
       _sharedTablesIsolationLevel = ValidateIsolationLevel(options.SharedTablesIsolationLevel);
       _isolationOptions = options.IsolationOptions;
       _masterConnection = options.MasterConnection ?? throw new ArgumentException($"The '{nameof(options.MasterConnection)}' cannot be null.", nameof(options));
@@ -157,7 +157,7 @@ public T CreateDbContext(bool useMasterConnection)
       }
 
       var options = useMasterConnection ? _masterDbContextOptions : _dbContextOptions;
-      var ctx = CreateDbContext(options, new DbDefaultSchema(Schema));
+      var ctx = CreateDbContext(options, Schema is null ? null : new DbDefaultSchema(Schema));
 
       foreach (var ctxInit in _contextInitializations)
       {
@@ -185,15 +185,15 @@ public T CreateDbContext(bool useMasterConnection)
    /// <param name="options">Options to use for creation.</param>
    /// <param name="schema">Database schema to use.</param>
    /// <returns>A new instance of the database context.</returns>
-   protected virtual T CreateDbContext(DbContextOptions<T> options, IDbDefaultSchema schema)
+   protected virtual T CreateDbContext(DbContextOptions<T> options, IDbDefaultSchema? schema)
    {
       var ctx = _contextFactory?.Invoke(options, schema)
                 ?? (_defaultContextFactory ??= CreateDefaultContextFactory())(options, schema);
 
       return ctx;
    }
 
-   private static Func<DbContextOptions<T>, IDbDefaultSchema, T> CreateDefaultContextFactory()
+   private static Func<DbContextOptions<T>, IDbDefaultSchema?, T> CreateDefaultContextFactory()
    {
       var optionsType = typeof(DbContextOptions<T>);
       var schemaType = typeof(IDbDefaultSchema);
@@ -221,7 +221,7 @@ private static Func<DbContextOptions<T>, IDbDefaultSchema, T> CreateDefaultConte
 Please provide the corresponding constructor or a custom factory via '{typeof(SqlServerTestDbContextProviderBuilder<T>).ShortDisplayName()}.{nameof(SqlServerTestDbContextProviderBuilder<T>.UseContextFactory)}'.");
       }
 
-      return Expression.Lambda<Func<DbContextOptions<T>, IDbDefaultSchema, T>>(Expression.New(ctor, ctorArgs), optionsParam, schemaParam)
+      return Expression.Lambda<Func<DbContextOptions<T>, IDbDefaultSchema?, T>>(Expression.New(ctor, ctorArgs), optionsParam, schemaParam)
                        .Compile();
    }
 
@@ -416,7 +416,7 @@ private async Task DisposeContextsAndRollbackMigrationsAsync(CancellationToken c
       if (_isolationOptions.NeedsCleanup)
       {
          // 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 using var ctx = _actDbContext ?? _arrangeDbContext ?? _assertDbContext ?? CreateDbContext(_masterDbContextOptions, Schema is null ? null : new DbDefaultSchema(Schema));
 
          IDbContextTransaction? migrationTx = null;
 

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

@@ -20,15 +20,15 @@ public class SqlServerTestDbContextProviderBuilder<T> : TestDbContextProviderBui
 
    private readonly string _connectionString;
    private readonly ITestIsolationOptions _isolationOptions;
-   private readonly List<Action<DbContextOptionsBuilder<T>, string>> _configuresOptionsCollection;
-   private readonly List<Action<SqlServerDbContextOptionsBuilder, string>> _configuresSqlServerOptionsCollection;
+   private readonly List<Action<DbContextOptionsBuilder<T>, string?>> _configuresOptionsCollection;
+   private readonly List<Action<SqlServerDbContextOptionsBuilder, string?>> _configuresSqlServerOptionsCollection;
    private readonly List<Action<T>> _ctxInitializations;
 
    private bool _useThinktectureSqlServerMigrationsSqlGenerator = true;
    private string? _sharedTablesSchema;
    private IsolationLevel? _sharedTablesIsolationLevel;
    private SqlServerLockTableOptions? _lockTable;
-   private Func<DbContextOptions<T>, IDbDefaultSchema, T?>? _contextFactory;
+   private Func<DbContextOptions<T>, IDbDefaultSchema?, T?>? _contextFactory;
    private Func<SqlServerTestDbContextProviderOptions<T>, SqlServerTestDbContextProvider<T>?>? _providerFactory;
 
    /// <summary>
@@ -51,8 +51,8 @@ public SqlServerTestDbContextProviderBuilder(string connectionString, ITestIsola
    {
       _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
       _isolationOptions = isolationOptions;
-      _configuresOptionsCollection = new List<Action<DbContextOptionsBuilder<T>, string>>();
-      _configuresSqlServerOptionsCollection = new List<Action<SqlServerDbContextOptionsBuilder, string>>();
+      _configuresOptionsCollection = new List<Action<DbContextOptionsBuilder<T>, string?>>();
+      _configuresSqlServerOptionsCollection = new List<Action<SqlServerDbContextOptionsBuilder, string?>>();
       _ctxInitializations = new List<Action<T>>();
    }
 
@@ -175,7 +175,7 @@ public SqlServerTestDbContextProviderBuilder<T> UseSharedTablesIsolationLevel(Is
    /// </summary>
    /// <param name="configure">Callback is called with the current <see cref="DbContextOptionsBuilder{TContext}"/> and the database schema.</param>
    /// <returns>Current builder for chaining.</returns>
-   public SqlServerTestDbContextProviderBuilder<T> ConfigureOptions(Action<DbContextOptionsBuilder<T>, string> configure)
+   public SqlServerTestDbContextProviderBuilder<T> ConfigureOptions(Action<DbContextOptionsBuilder<T>, string?> configure)
    {
       ArgumentNullException.ThrowIfNull(configure);
 
@@ -189,7 +189,7 @@ public SqlServerTestDbContextProviderBuilder<T> ConfigureOptions(Action<DbContex
    /// </summary>
    /// <param name="configure">Callback is called with the current <see cref="DbContextOptionsBuilder{TContext}"/> and the database schema.</param>
    /// <returns>Current builder for chaining.</returns>
-   public SqlServerTestDbContextProviderBuilder<T> ConfigureSqlServerOptions(Action<SqlServerDbContextOptionsBuilder, string> configure)
+   public SqlServerTestDbContextProviderBuilder<T> ConfigureSqlServerOptions(Action<SqlServerDbContextOptionsBuilder, string?> configure)
    {
       ArgumentNullException.ThrowIfNull(configure);
 
@@ -267,7 +267,7 @@ public SqlServerTestDbContextProviderBuilder<T> InitializeContext(Action<T> init
    /// </summary>
    /// <param name="contextFactory">Factory to create the context of type <typeparamref name="T"/>.</param>
    /// <returns>Current builder for chaining.</returns>
-   public SqlServerTestDbContextProviderBuilder<T> UseContextFactory(Func<DbContextOptions<T>, IDbDefaultSchema, T?>? contextFactory)
+   public SqlServerTestDbContextProviderBuilder<T> UseContextFactory(Func<DbContextOptions<T>, IDbDefaultSchema?, T?>? contextFactory)
    {
       _contextFactory = contextFactory;
 
@@ -292,7 +292,7 @@ public SqlServerTestDbContextProviderBuilder<T> UseProviderFactory(Func<SqlServe
    /// <param name="useSharedTables">Indication whether a new schema should be generated or a shared one.</param>
    /// <returns>A database schema.</returns>
    [Obsolete($"Use the overload with '{nameof(ITestIsolationOptions)}' instead.")]
-   protected virtual string DetermineSchema(bool useSharedTables)
+   protected virtual string? DetermineSchema(bool useSharedTables)
    {
       return DetermineSchema(useSharedTables ? ITestIsolationOptions.SharedTablesAmbientTransaction : ITestIsolationOptions.RollbackMigrationsAndCleanup);
    }
@@ -302,22 +302,22 @@ protected virtual string DetermineSchema(bool useSharedTables)
    /// </summary>
    /// <param name="isolationOptions">Test isolation behavior.</param>
    /// <returns>A database schema.</returns>
-   protected virtual string DetermineSchema(ITestIsolationOptions isolationOptions)
+   protected virtual string? DetermineSchema(ITestIsolationOptions isolationOptions)
    {
       return !isolationOptions.NeedsUniqueSchema
-                ? _sharedTablesSchema ?? "tests"
+                ? _sharedTablesSchema
                 : Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
    }
 
    /// <summary>
    /// Creates and configures the <see cref="DbContextOptionsBuilder{TContext}"/>
    /// </summary>
    /// <param name="connection">Database connection to use.</param>
-   /// <param name="schema">Database schema to use.</param>
+   /// <param name="schema">Default database schema to use.</param>
    /// <returns>An instance of <see cref="DbContextOptionsBuilder{TContext}"/></returns>
    public virtual DbContextOptionsBuilder<T> CreateOptionsBuilder(
       DbConnection? connection,
-      string schema)
+      string? schema)
    {
       var loggingOptions = CreateLoggingOptions();
       var state = new TestDbContextProviderBuilderState(loggingOptions);
@@ -330,12 +330,12 @@ public virtual DbContextOptionsBuilder<T> CreateOptionsBuilder(
    /// </summary>
    /// <param name="state">Current building state.</param>
    /// <param name="connection">Database connection to use.</param>
-   /// <param name="schema">Database schema to use.</param>
+   /// <param name="schema">Default database schema to use.</param>
    /// <returns>An instance of <see cref="DbContextOptionsBuilder{TContext}"/></returns>
    protected virtual DbContextOptionsBuilder<T> CreateOptionsBuilder(
       TestDbContextProviderBuilderState state,
       DbConnection? connection,
-      string schema)
+      string? schema)
    {
       var builder = new DbContextOptionsBuilder<T>();
 
@@ -348,7 +348,8 @@ protected virtual DbContextOptionsBuilder<T> CreateOptionsBuilder(
          builder.UseSqlServer(connection, optionsBuilder => ConfigureSqlServer(optionsBuilder, schema));
       }
 
-      builder.AddSchemaRespectingComponents();
+      if (schema is not null)
+         builder.AddSchemaRespectingComponents();
 
       ApplyDefaultConfiguration(state, builder);
 
@@ -363,7 +364,7 @@ protected virtual DbContextOptionsBuilder<T> CreateOptionsBuilder(
    /// <param name="builder">A builder for configuration of the options.</param>
    /// <param name="schema">Schema to use</param>
    /// <exception cref="ArgumentNullException">The <paramref name="builder"/> is null.</exception>
-   protected virtual void ConfigureSqlServer(SqlServerDbContextOptionsBuilder builder, string schema)
+   protected virtual void ConfigureSqlServer(SqlServerDbContextOptionsBuilder builder, string? schema)
    {
       ArgumentNullException.ThrowIfNull(builder);
 

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

@@ -35,14 +35,14 @@ public ITestIsolationOptions IsolationOptions
    }
 
    /// <summary>
-   /// Database schema to use.
+   /// Default database schema to use.
    /// </summary>
-   public string Schema { get; set; }
+   public string? Schema { get; }
 
    /// <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; set; }
 
    /// <summary>
    /// Isolation level to be used with shared tables.
@@ -72,7 +72,7 @@ public SqlServerTestDbContextProviderOptions(
       DbContextOptions<T> dbContextOptions,
       TestingLoggingOptions testingLoggingOptions,
       IReadOnlyList<Action<T>> contextInitializations,
-      string schema)
+      string? schema)
       : base(masterConnection, migrationExecutionStrategy, masterDbContextOptions, dbContextOptions, testingLoggingOptions, contextInitializations)
    {
       Schema = schema;