Add SQLite integration tests for runtime migrations and fix service wiring

Integration tests:
- Can_create_and_apply_initial_migration
- Can_create_and_apply_initial_migration_async
- Can_create_migration_with_dry_run
- CreateAndApplyMigration_generates_valid_sql_commands
- CreateAndApplyMigration_throws_when_no_pending_changes
- Can_create_migration_with_custom_namespace
- Can_check_for_pending_model_changes
- Applied_migration_appears_in_migration_history

Service wiring fixes:
- Create DynamicMigrationsAssembly in AddDbContextDesignTimeServices to properly wrap context's IMigrationsAssembly
- Register DynamicMigrationsAssembly as both IDynamicMigrationsAssembly and IMigrationsAssembly
- Add IDesignTimeModel registration from context

RuntimeMigrationService changes:
- Apply migrations directly instead of using IMigrator.Migrate() to avoid migration lookup issues
- Add ApplyMigration and ApplyMigrationAsync methods that execute commands directly
- Inject additional services: IMigrationCommandExecutor, IRelationalConnection, IRawSqlCommandBuilder, IRelationalCommandDiagnosticsLogger

Author: thromel

src/EFCore.Design/Design/DesignTimeServiceCollectionExtensions.cs

@@ -68,8 +68,8 @@ public static IServiceCollection AddEntityFrameworkDesignTimeServices(
                 .TryAddScoped<IMigrationsScaffolder, MigrationsScaffolder>()
                 .TryAddScoped<ISnapshotModelProcessor, SnapshotModelProcessor>()
                 .TryAddSingleton<IMigrationCompiler, CSharpMigrationCompiler>()
-                .TryAddScoped<IDynamicMigrationsAssembly>(sp =>
-                    new DynamicMigrationsAssembly(sp.GetRequiredService<IMigrationsAssembly>()))
+                // Note: IDynamicMigrationsAssembly and IMigrationsAssembly are registered in
+                // AddDbContextDesignTimeServices to ensure proper wrapping of the context's assembly
                 .TryAddScoped<IRuntimeMigrationService, RuntimeMigrationService>());
 
         var loggerFactory = new LoggerFactory(
@@ -92,6 +92,12 @@ public static IServiceCollection AddDbContextDesignTimeServices(
         this IServiceCollection services,
         DbContext context)
     {
+        // Get the context's IMigrationsAssembly to wrap in DynamicMigrationsAssembly
+        var innerMigrationsAssembly = context.GetService<IMigrationsAssembly>();
+
+        // Create DynamicMigrationsAssembly wrapping the context's IMigrationsAssembly
+        var dynamicMigrationsAssembly = new DynamicMigrationsAssembly(innerMigrationsAssembly);
+
         new EntityFrameworkRelationalServicesBuilder(services)
             .TryAdd(context.GetService<IDatabaseProvider>())
             .TryAdd(_ => context.GetService<IMigrationsIdGenerator>())
@@ -101,10 +107,18 @@ public static IServiceCollection AddDbContextDesignTimeServices(
             .TryAdd(_ => context.GetService<ICurrentDbContext>())
             .TryAdd(_ => context.GetService<IDbContextOptions>())
             .TryAdd(_ => context.GetService<IHistoryRepository>())
-            .TryAdd(_ => context.GetService<IMigrationsAssembly>())
             .TryAdd(_ => context.GetService<IMigrationsModelDiffer>())
             .TryAdd(_ => context.GetService<IMigrator>())
+            .TryAdd(_ => context.GetService<IDesignTimeModel>())
             .TryAdd(_ => context.GetService<IDesignTimeModel>().Model);
+
+        // Register DynamicMigrationsAssembly as both IDynamicMigrationsAssembly and IMigrationsAssembly
+        // Note: For runtime migration to work, the IMigrator from context needs to be updated to use
+        // DynamicMigrationsAssembly, which isn't directly possible. The RuntimeMigrationService handles
+        // this by registering migrations with DynamicMigrationsAssembly and calling the context's Migrator.
+        services.AddScoped<IDynamicMigrationsAssembly>(_ => dynamicMigrationsAssembly);
+        services.AddScoped<IMigrationsAssembly>(_ => dynamicMigrationsAssembly);
+
         return services;
     }
 }

src/EFCore.Design/Migrations/Design/RuntimeMigrationService.cs

@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.EntityFrameworkCore.Storage;
 
 namespace Microsoft.EntityFrameworkCore.Migrations.Design;
 
@@ -34,6 +36,11 @@ public class RuntimeMigrationService : IRuntimeMigrationService
     private readonly IMigrator _migrator;
     private readonly IMigrationsSqlGenerator _sqlGenerator;
     private readonly IRelationalDatabaseCreator _databaseCreator;
+    private readonly IMigrationCommandExecutor _commandExecutor;
+    private readonly IRelationalConnection _connection;
+    private readonly IHistoryRepository _historyRepository;
+    private readonly IRawSqlCommandBuilder _rawSqlCommandBuilder;
+    private readonly IRelationalCommandDiagnosticsLogger _commandLogger;
 
     /// <summary>
     ///     Initializes a new instance of the <see cref="RuntimeMigrationService" /> class.
@@ -45,14 +52,24 @@ public class RuntimeMigrationService : IRuntimeMigrationService
     /// <param name="migrator">The migrator.</param>
     /// <param name="sqlGenerator">The SQL generator.</param>
     /// <param name="databaseCreator">The database creator.</param>
+    /// <param name="commandExecutor">The migration command executor.</param>
+    /// <param name="connection">The relational connection.</param>
+    /// <param name="historyRepository">The history repository.</param>
+    /// <param name="rawSqlCommandBuilder">The raw SQL command builder.</param>
+    /// <param name="commandLogger">The command logger.</param>
     public RuntimeMigrationService(
         ICurrentDbContext currentContext,
         IMigrationsScaffolder scaffolder,
         IMigrationCompiler compiler,
         IDynamicMigrationsAssembly dynamicMigrationsAssembly,
         IMigrator migrator,
         IMigrationsSqlGenerator sqlGenerator,
-        IRelationalDatabaseCreator databaseCreator)
+        IRelationalDatabaseCreator databaseCreator,
+        IMigrationCommandExecutor commandExecutor,
+        IRelationalConnection connection,
+        IHistoryRepository historyRepository,
+        IRawSqlCommandBuilder rawSqlCommandBuilder,
+        IRelationalCommandDiagnosticsLogger commandLogger)
     {
         _currentContext = currentContext;
         _scaffolder = scaffolder;
@@ -61,6 +78,11 @@ public RuntimeMigrationService(
         _migrator = migrator;
         _sqlGenerator = sqlGenerator;
         _databaseCreator = databaseCreator;
+        _commandExecutor = commandExecutor;
+        _connection = connection;
+        _historyRepository = historyRepository;
+        _rawSqlCommandBuilder = rawSqlCommandBuilder;
+        _commandLogger = commandLogger;
     }
 
     /// <inheritdoc />
@@ -113,7 +135,7 @@ public virtual RuntimeMigrationResult CreateAndApplyMigration(
         var applied = false;
         if (!options.DryRun)
         {
-            _migrator.Migrate(compiledMigration.MigrationId);
+            ApplyMigration(compiledMigration, sqlCommands);
             applied = true;
         }
 
@@ -177,7 +199,7 @@ public virtual async Task<RuntimeMigrationResult> CreateAndApplyMigrationAsync(
         var applied = false;
         if (!options.DryRun)
         {
-            await _migrator.MigrateAsync(compiledMigration.MigrationId, cancellationToken)
+            await ApplyMigrationAsync(compiledMigration, sqlCommands, cancellationToken)
                 .ConfigureAwait(false);
             applied = true;
         }
@@ -191,6 +213,104 @@ await _migrator.MigrateAsync(compiledMigration.MigrationId, cancellationToken)
             savedFiles?.SnapshotFile);
     }
 
+    /// <summary>
+    ///     Applies a compiled migration to the database.
+    /// </summary>
+    /// <param name="compiledMigration">The compiled migration to apply.</param>
+    /// <param name="sqlCommands">The pre-generated SQL commands.</param>
+    protected virtual void ApplyMigration(CompiledMigration compiledMigration, IReadOnlyList<string> sqlCommands)
+    {
+        // Ensure database exists
+        if (!_databaseCreator.Exists())
+        {
+            _databaseCreator.Create();
+        }
+
+        _connection.Open();
+        try
+        {
+            // Ensure history table exists
+            if (!_historyRepository.Exists())
+            {
+                _historyRepository.Create();
+            }
+
+            // Get the migration and its operations
+            var migration = _dynamicMigrationsAssembly.CreateMigration(
+                compiledMigration.MigrationTypeInfo,
+                _currentContext.Context.Database.ProviderName!);
+
+            // Build the history insert command
+            var insertCommand = _rawSqlCommandBuilder.Build(
+                _historyRepository.GetInsertScript(new HistoryRow(compiledMigration.MigrationId, ProductInfo.GetVersion())));
+
+            // Generate migration commands and append history insert
+            var migrationCommands = _sqlGenerator.Generate(
+                migration.UpOperations,
+                _currentContext.Context.Model).ToList();
+            migrationCommands.Add(new MigrationCommand(insertCommand, _currentContext.Context, _commandLogger));
+
+            // Execute all commands
+            _commandExecutor.ExecuteNonQuery(migrationCommands, _connection);
+        }
+        finally
+        {
+            _connection.Close();
+        }
+    }
+
+    /// <summary>
+    ///     Applies a compiled migration to the database asynchronously.
+    /// </summary>
+    /// <param name="compiledMigration">The compiled migration to apply.</param>
+    /// <param name="sqlCommands">The pre-generated SQL commands.</param>
+    /// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    protected virtual async Task ApplyMigrationAsync(
+        CompiledMigration compiledMigration,
+        IReadOnlyList<string> sqlCommands,
+        CancellationToken cancellationToken = default)
+    {
+        // Ensure database exists
+        if (!await _databaseCreator.ExistsAsync(cancellationToken).ConfigureAwait(false))
+        {
+            await _databaseCreator.CreateAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        await _connection.OpenAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            // Ensure history table exists
+            if (!await _historyRepository.ExistsAsync(cancellationToken).ConfigureAwait(false))
+            {
+                await _historyRepository.CreateAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            // Get the migration and its operations
+            var migration = _dynamicMigrationsAssembly.CreateMigration(
+                compiledMigration.MigrationTypeInfo,
+                _currentContext.Context.Database.ProviderName!);
+
+            // Build the history insert command
+            var insertCommand = _rawSqlCommandBuilder.Build(
+                _historyRepository.GetInsertScript(new HistoryRow(compiledMigration.MigrationId, ProductInfo.GetVersion())));
+
+            // Generate migration commands and append history insert
+            var migrationCommands = _sqlGenerator.Generate(
+                migration.UpOperations,
+                _currentContext.Context.Model).ToList();
+            migrationCommands.Add(new MigrationCommand(insertCommand, _currentContext.Context, _commandLogger));
+
+            // Execute all commands
+            await _commandExecutor.ExecuteNonQueryAsync(migrationCommands, _connection, cancellationToken)
+                .ConfigureAwait(false);
+        }
+        finally
+        {
+            await _connection.CloseAsync().ConfigureAwait(false);
+        }
+    }
+
     /// <inheritdoc />
     public virtual bool HasPendingModelChanges()
         => _migrator.HasPendingModelChanges();