HasPendingModelChanges() always returns true

[charlesRollandy]

I have an application with a database project and a data migration project. I wrote a unit test in a dedicated project to test there is no pending changes in my model and no migration is required.

My solution has the following structure:

MySolution
├ Database/
|    ├ Entities/
|    |     User.cs
|    |     Group.cs
|    |     ...
|    AppDbContext.cs   
├ Database.Migrations/
|    ├ Migrations/
|    DesignTimeDbContextFactory.cs
├ App.UnitTests/
|    AppDbContextTests.cs   

This us my unit test in AppDbContext.cs:

public class AppDbContextTests
{
    [Test]
    public void Database_shouldNotHavePendingModelChanges()
    {
        using(var context = CreateAppDbContext())
        {
            var hasChanges = context.Database.HasPendingModelChanges();
            Assert.That(hasChanges, Is.False, "The dabatase has model changes pending. Create a new migration for it.");
        }        
    }

    private AppDbContext CreateAppDbContext()
    {
        var connection = new SqliteConnection("Filename=:memory:");
        connection.Open();
        
        var dbContextOptions = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlite(
                connection,
                b => b.MigrationsAssembly(Assembly.GetAssembly(typeof(DesignTimeDbContextFactory))!.GetName().Name))
            .Options;
        
        return new AppDbContext(dbContextOptions);
    }
}

This test always fails. HasPendingModelChanges always returns true

This is the code of DesignTimeDbContextFactory.cs

public class DesignTimeDbContextFactory: IDesignTimeDbContextFactory<AppDbContext>
{
    public AppDbContext CreateDbContext(string[] args)
    {
        // Build config
        IConfiguration config = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
# if DEBUG
            .AddJsonFile($"appsettings.local.json")
#endif
            .AddEnvironmentVariables()
            .Build();

        // Get connection string
        var optionsBuilder = new DbContextOptionsBuilder<AppDbContext>();
        optionsBuilder.UseSqlServer(config.GetValue<string>(AppDbContext.ConfigurationKey),
            b => b.MigrationsAssembly(Assembly.GetExecutingAssembly().GetName().Name));
        return new AppDbContext(optionsBuilder.Options);
    }
}

When I open a terminal from the Database.Migrations folder and run the command dotnet ef migrations has-pending-model-changes it gives me the correct result.
I tried using the same database provider in my unit test but the result was the same. It doesn't look to be related to that.

EF Core version: 8.0.10
Target framework: (e.g. .NET 8.0)
Operating system: Windows 11
IDE: (e.g. Visual Studio 2022 17.11.5)

[ajcvickers]

@charlesRollandy I may be missing something here, but if you create a new, empty, SQLite in-memory database, then the schema will be empty and HasPendingModelChanges should always return true.

[charlesRollandy]

@ajcvickers HasPendingModelChanges is not looking if the model changes are applied to the database but if some changes into the entities are not reflected with migrations.

What is actually weird is that the cli provides the correct result but not the method from the SDK. Could if be related to configuration ?

[ajcvickers]

@charlesRollandy Thanks for pointing that out. I investigated this further, and it looks like the issue is that the migration created on the command line is for SQL Server, while the test is for SQLite. Migrations are database specific, so the migration generated for SQL Server will not be the same as one generated for SQLite, meaning that the models will be different and this warning is generated.

Note for team: we could consider explicitly checking for different providers. Related to #15174 and #16406.

[ajcvickers]

Decision from team meeting: bump the priority of #15174

[tvardero]

TLDR:
Issue might still affect you if you use Microsoft.AspNetCore.Identity, your DbContext inherits from IdentityDbContext and you have identityOptions.Store.MaxLengthForKeys set to non-default value. Create unit tests carefully, read below.

---

Issue still exists for Pomelo.EntityFrameworkCore.MySql v9.0.0 (references Microsoft.EntityFrameworkCore.Relational 9.0.0).

_mySqlContainer is TestContainer for mysql. In runtime we connect to AWS RDS mysql in prod, and to docker mysql container in localhost development.

.HasPendingModelChanges() always returns true in unit/integration tests. Without or with applying migrations.
Migrations in unit tests are applied correctly, from /Migrations folder where AppDbContext exists.
dotnet migrations add returns empty migration and AppDbContextModelSnapshot differs only in whitespaces.
However, .HasPendingModelChanges() returns false when executed in real application (either prod to AWS RDS or development to localhost mysql).

[Fact]
public async Task AppDbContext_MySql_NoPendingChanges()
{
    DbContextOptionsBuilder<AppDbContext> dbCtxOptions = await GetDbContextOptionsBuilderAsync();
    await using var db = new AppDbContext(dbCtxOptions.Options);

    Assert.False(db.Database.HasPendingModelChanges()); // <-- this does not work

    // after applying migrations:
    await db.Database.MigrateAsync(TestContext.Current.CancellationToken);
    Assert.False(db.Database.HasPendingModelChanges()); // <-- this does not work as well
}

private async Task<DbContextOptionsBuilder<AppDbContext>> GetDbContextOptionsBuilderAsync([CallerMemberName] string? dbName = null)
{
    string connection = _mySqlContainer.GetConnectionString(dbName ?? Guid.NewGuid().ToString("N"));
    ServerVersion serverVersion = await ServerVersion.AutoDetectAsync(connection, TestContext.Current.CancellationToken);

    DbContextOptionsBuilder<AppDbContext> builder = new DbContextOptionsBuilder<AppDbContext>()
        .UseMySql(connection, serverVersion)
        .EnableDetailedErrors()
        .EnableSensitiveDataLogging()
        .ConfigureWarnings(warn => warn.Ignore(CoreEventId.SensitiveDataLoggingEnabledWarning))
        .UseLoggerFactory(_loggerFactory)
        .EnableServiceProviderCaching(false);

    return builder;
}

For now I'm skipping this test and do the check in runtime, however I would like to not.
Can someone advise what might be wrong?

---

UPD: Removing EnableServiceProviderCaching(false) did not help. Was used as there are multiple other tests for db, and some of them test model creation.

UPD2: Explicitly specifying migration assembly did not help either .UseMySql(connection, serverVersion, mysql => mysql.MigrationsAssembly(typeof(AppDbContext).Assembly))

UPD3: Using this code I have found some strange pending changes, which never appear in dotnet-ef migrations add.

[
  {
    "OldColumn": {
      "Name": null,
      "Schema": null,
      "Table": null,
      "ClrType": "System.String, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e",
      "ColumnType": "varchar(128)",
      "IsUnicode": null,
      "IsFixedLength": null,
      "MaxLength": 128,
      "Precision": null,
      "Scale": null,
      "IsRowVersion": false,
      "IsNullable": false,
      "DefaultValue": null,
      "DefaultValueSql": null,
      "ComputedColumnSql": null,
      "IsStored": null,
      "Comment": null,
      "Collation": null,
      "IsDestructiveChange": false,
      "IsReadOnly": false
    },
    "Name": "ProviderKey",
    "Schema": null,
    "Table": "AspNetUserLogins",
    "ClrType": "System.String, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e",
    "ColumnType": "varchar(255)",
    "IsUnicode": null,
    "IsFixedLength": null,
    "MaxLength": null,
    "Precision": null,
    "Scale": null,
    "IsRowVersion": false,
    "IsNullable": false,
    "DefaultValue": null,
    "DefaultValueSql": null,
    "ComputedColumnSql": null,
    "IsStored": null,
    "Comment": null,
    "Collation": null,
    "IsDestructiveChange": true,
    "IsReadOnly": false
  },
  {
    "OldColumn": {
      "Name": null,
      "Schema": null,
      "Table": null,
      "ClrType": "System.String, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e",
      "ColumnType": "varchar(128)",
      "IsUnicode": null,
      "IsFixedLength": null,
      "MaxLength": 128,
      "Precision": null,
      "Scale": null,
      "IsRowVersion": false,
      "IsNullable": false,
      "DefaultValue": null,
      "DefaultValueSql": null,
      "ComputedColumnSql": null,
      "IsStored": null,
      "Comment": null,
      "Collation": null,
      "IsDestructiveChange": false,
      "IsReadOnly": false
    },
    "Name": "LoginProvider",
    "Schema": null,
    "Table": "AspNetUserLogins",
    "ClrType": "System.String, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e",
    "ColumnType": "varchar(255)",
    "IsUnicode": null,
    "IsFixedLength": null,
    "MaxLength": null,
    "Precision": null,
    "Scale": null,
    "IsRowVersion": false,
    "IsNullable": false,
    "DefaultValue": null,
    "DefaultValueSql": null,
    "ComputedColumnSql": null,
    "IsStored": null,
    "Comment": null,
    "Collation": null,
    "IsDestructiveChange": true,
    "IsReadOnly": false
  }
]

Both have changed columns in AspNetUserLogin table.
We do not use this table and have no IEntityTypeConfiguration for in the project. Those columns change their max length properties somehow on their own, depending if they are executed in unit tests or not.

For context, our AppDbContext inherits from IdentityDbContext<User, Role, Guid>.

/// <inheritdoc />
protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder); // <-- we do call that

    // these are our own entities, not related to IdentityDbContext
    Type[] configurationsToExclude =
    [
        typeof(StripeTransactionConfiguration),
        typeof(StripeTransactionItemConfiguration),
        typeof(DnsRecordConfiguration),
        typeof(OAuthTwilioConfiguration),
        typeof(OwnEmailDomainConfiguration),
        typeof(SavedRepliesConfiguration),
        typeof(ScanhubCaseSessionConfiguration),
        typeof(SingleSenderEmailConfiguration),
        typeof(UnassignedConversationConfiguration),
        typeof(UnassignedOrderNoteConfiguration),
    ];

    builder.ApplyConfigurationsFromAssembly(typeof(AppDbContext).Assembly, t => !configurationsToExclude.Contains(t));
}

I suspect test fails because:

1. db context created without use of DI / serviceProvider,
2. .AddIdentityCore<User>() and .AddEntityFrameworkStores<AppDbContext>() are not executed, so their services do not exist in the test. And suspicion is that some service additionally configures AppDbContext outside of OnModelCreating of IdentityDbContext. Our AddIdentityCore has this option: options.Stores.MaxLengthForKeys = 128;

UPD4: It was true. Fixed by creating service collection, registering AppDbContext, registering Identity services with MaxLengthForKeys = 128, and then using DbContext from that service provider. IdentityDbContext.OnModelCreating in fact has a dependency on IOptions<Microsoft.AspNetCore.Identity.StoreOptions>.