Convert all 299 obsolete GearsOfWar, Northwind, and other test overrides to standalone MySQL tests for EF Core 10

test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs

@@ -9,9 +9,20 @@
 
 public class NonSharedModelBulkUpdatesMySqlTest : NonSharedModelBulkUpdatesRelationalTestBase
 {
+    public NonSharedModelBulkUpdatesMySqlTest()
+        : base(new MySqlNonSharedModelBulkUpdatesFixture())
+    {
+    }
+
     protected override ITestStoreFactory TestStoreFactory
         => MySqlTestStoreFactory.Instance;
 
+    public class MySqlNonSharedModelBulkUpdatesFixture : NonSharedModelBulkUpdatesFixtureBase
+    {
+        protected override string StoreName => "NonSharedModelBulkUpdates";
+        protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance;
+    }
+
     [ConditionalFact]
     public virtual void Check_all_tests_overridden()
         => MySqlTestHelpers.AssertAllMethodsOverridden(GetType());

test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs

@@ -530,9 +530,20 @@ LIMIT @__p_1 OFFSET @__p_0
 """);
     }
 
-    public override async Task Delete_with_left_join(bool async)
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Delete_with_left_join(bool async)
     {
-        await base.Delete_with_left_join(async);
+        await AssertDelete(
+            async,
+            ss => ss.Set<OrderDetail>().Where(
+                od => ss.Set<Order>()
+                    .Where(o => o.OrderID < 10300)
+                    .OrderBy(o => o.OrderID)
+                    .Skip(0)
+                    .Take(100)
+                    .Select(o => o.OrderID)
+                    .Contains(od.OrderID)));
 
         AssertSql(
 """
@@ -1086,9 +1097,15 @@ public override async Task Update_without_property_to_set_throws(bool async)
         AssertExecuteUpdateSql();
     }
 
-    public override async Task Update_with_invalid_lambda_throws(bool async)
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Update_with_invalid_lambda_throws(bool async)
     {
-        await base.Update_with_invalid_lambda_throws(async);
+        await AssertTranslationFailed(
+            () => AssertUpdate(
+                async,
+                ss => ss.Set<Customer>().Where(c => c.CustomerID.StartsWith("F")),
+                _ => new Customer { City = "invalidValue" }));
 
         AssertExecuteUpdateSql();
     }
@@ -1219,9 +1236,14 @@ INNER JOIN (
 """);
     }
 
-    public override async Task Update_with_left_join_set_constant(bool async)
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Update_with_left_join_set_constant(bool async)
     {
-        await base.Update_with_left_join_set_constant(async);
+        await AssertUpdate(
+            async,
+            ss => ss.Set<Customer>().Where(c => c.CustomerID.StartsWith("F")),
+            e => e.SetProperty(p => p.ContactName, "Updated"));
 
         AssertExecuteUpdateSql(
 """

test/EFCore.MySql.FunctionalTests/MaterializationInterceptionMySqlTest.cs

@@ -6,6 +6,11 @@
 
 public class MaterializationInterceptionMySqlTest : MaterializationInterceptionTestBase<MaterializationInterceptionMySqlTest.MySqlLibraryContext>
 {
+    public MaterializationInterceptionMySqlTest()
+        : base(new MySqlMaterializationInterceptionFixture())
+    {
+    }
+
     public class MySqlLibraryContext : LibraryContext
     {
         public MySqlLibraryContext(DbContextOptions options)
@@ -26,4 +31,15 @@
 
     protected override ITestStoreFactory TestStoreFactory
         => MySqlTestStoreFactory.Instance;
+
+    public class MySqlMaterializationInterceptionFixture : SingletonInterceptorsFixtureBase
+    {
+        protected override string StoreName => "MaterializationInterception";
+        protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance;
+
+        protected override IServiceCollection InjectInterceptors(
+            IServiceCollection serviceCollection,
+            IEnumerable<IInterceptor> injectedInterceptors)
+            => base.InjectInterceptors(serviceCollection.AddEntityFrameworkMySql(), injectedInterceptors);
+    }
 }

test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs

@@ -34,10 +34,10 @@ public override async Task Multiple_different_entity_type_from_different_namespa
         var bad = context.Set<TestQuery>().FromSqlRaw(@"SELECT cast(null as signed) AS MyValue").ToList(); // Exception
     }
 
-    protected override Task SetParameterizedCollectionMode(DbContextOptionsBuilder optionsBuilder, ParameterTranslationMode mode)
+    protected override DbContextOptionsBuilder SetParameterizedCollectionMode(DbContextOptionsBuilder optionsBuilder, ParameterTranslationMode mode)
     {
         // MySQL-specific parameter handling configuration
         // For now, use default MySQL behavior as the implementation is provider-specific
-        return Task.CompletedTask;
+        return optionsBuilder;
     }
 }

test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs

@@ -34,7 +34,9 @@ public override Task DateTimeOffset_Contains_Less_than_Greater_than(bool async)
                     m => start <= m.Timeline.Date && m.Timeline < end && dates.Contains(m.Timeline)));
         }
 
-        public override Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async)
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async)
         {
             var dateTimeOffset = MySqlTestHelpers.GetExpectedValue(new DateTimeOffset(599898024001234567, new TimeSpan(1, 30, 0)));
 
@@ -250,9 +252,13 @@ GROUP BY `g0`.`Key`
 """);
         }
 
-        public override async Task Array_access_on_byte_array(bool async)
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task Array_access_on_byte_array(bool async)
         {
-            await base.Array_access_on_byte_array(async);
+            await AssertQuery(
+                async,
+                ss => ss.Set<Squad>().Where(s => s.Banner5[2] == 6));
 
             AssertSql(
 """
@@ -262,9 +268,30 @@ WHERE ASCII(SUBSTRING(`s`.`Banner5`, 2 + 1, 1)) = 6
 """);
         }
 
-        public override async Task DateTimeOffset_to_unix_time_milliseconds(bool async)
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task DateTimeOffset_to_unix_time_milliseconds(bool async)
         {
-            await base.DateTimeOffset_to_unix_time_milliseconds(async);
+            var unixEpochMilliseconds = 0L;
+
+            await AssertQuery(
+                async,
+                ss => from g in ss.Set<Gear>()
+                      join squad in ss.Set<Squad>() on g.SquadId equals squad.Id
+                      where !ss.Set<SquadMission>()
+                          .Join(ss.Set<Mission>(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m })
+                          .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds)
+                          .Any()
+                      select g,
+                ss => from g in ss.Set<Gear>()
+                      join squad in ss.Set<Squad>() on g.SquadId equals squad.Id
+                      where !ss.Set<SquadMission>()
+                          .Join(ss.Set<Mission>(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m })
+                          .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds)
+                          .Any()
+                      select g,
+                elementSorter: e => (e.Nickname, e.SquadId),
+                elementAsserter: (e, a) => AssertEqual(e, a));
 
             AssertSql(
 """
@@ -283,9 +310,30 @@ SELECT 1
 """);
         }
 
-        public override async Task DateTimeOffset_to_unix_time_seconds(bool async)
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task DateTimeOffset_to_unix_time_seconds(bool async)
         {
-            await base.DateTimeOffset_to_unix_time_seconds(async);
+            var unixEpochSeconds = 0L;
+
+            await AssertQuery(
+                async,
+                ss => from g in ss.Set<Gear>()
+                      join squad in ss.Set<Squad>() on g.SquadId equals squad.Id
+                      where !ss.Set<SquadMission>()
+                          .Join(ss.Set<Mission>(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m })
+                          .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds)
+                          .Any()
+                      select g,
+                ss => from g in ss.Set<Gear>()
+                      join squad in ss.Set<Squad>() on g.SquadId equals squad.Id
+                      where !ss.Set<SquadMission>()
+                          .Join(ss.Set<Mission>(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m })
+                          .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds)
+                          .Any()
+                      select g,
+                elementSorter: e => (e.Nickname, e.SquadId),
+                elementAsserter: (e, a) => AssertEqual(e, a));
 
             AssertSql(
 """
@@ -339,7 +387,9 @@ public override async Task Where_subquery_with_ElementAt_using_column_as_index(b
             AssertSql("");
         }
 
-        public override async Task Where_datetimeoffset_hour_component(bool async)
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task Where_datetimeoffset_hour_component(bool async)
         {
             await AssertQuery(
                 async,

test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs

@@ -479,9 +479,18 @@ public override async Task Column_collection_inside_json_owned_entity()
 
     #endregion Type mapping inference
 
-    public override async Task Parameter_collection_Count_with_column_predicate_with_default_constants()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_constants(bool async)
     {
-        await base.Parameter_collection_Count_with_column_predicate_with_default_constants();
+        var contextFactory = await InitializeAsync<Context30572>(seed: c => c.Seed());
+
+        await using var context = contextFactory.CreateContext();
+
+        await AssertQuery(
+            async,
+            ss => ss.Set<Context30572.TestEntity>()
+                .Where(t => new[] { 2, 999 }.Count(i => i > t.Id) == 1));
 
         AssertSql(
 $"""
@@ -494,9 +503,18 @@ SELECT COUNT(*)
 """);
     }
 
-    public override async Task Parameter_collection_of_ints_Contains_int_with_default_constants()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_constants(bool async)
     {
-        await base.Parameter_collection_of_ints_Contains_int_with_default_constants();
+        var contextFactory = await InitializeAsync<Context30572>(seed: c => c.Seed());
+
+        await using var context = contextFactory.CreateContext();
+
+        await AssertQuery(
+            async,
+            ss => ss.Set<Context30572.TestEntity>()
+                .Where(t => new[] { 2, 999 }.Contains(t.Id)));
 
         AssertSql(
 """
@@ -506,37 +524,61 @@ public override async Task Parameter_collection_of_ints_Contains_int_with_defaul
 """);
     }
 
-    public override async Task Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter(bool async)
     {
-        await base.Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter();
+        await AssertQuery(
+            async,
+            ss => ss.Set<TestEntity>().Where(x => new[] { 2, 999 }.Count(i => i > x.Id) == 1));
 
         AssertSql();
     }
 
-    public override async Task Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter(bool async)
     {
-        await base.Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter();
+        await AssertQuery(
+            async,
+            ss => ss.Set<TestEntity>().Where(x => new[] { 2, 999 }.Contains(x.Id)));
 
         AssertSql();
     }
 
-    public override async Task Parameter_collection_Count_with_column_predicate_with_default_parameters()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_parameters(bool async)
     {
-        await base.Parameter_collection_Count_with_column_predicate_with_default_parameters();
+        var ints = new[] { 2, 999 };
+        await AssertQuery(
+            async,
+            ss => ss.Set<TestEntity>().Where(x => ints.Count(i => i > x.Id) == 1));
 
         AssertSql();
     }
 
-    public override async Task Parameter_collection_of_ints_Contains_int_with_default_parameters()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_parameters(bool async)
     {
-        await base.Parameter_collection_of_ints_Contains_int_with_default_parameters();
+        var ints = new[] { 2, 999 };
+        await AssertQuery(
+            async,
+            ss => ss.Set<TestEntity>().Where(x => ints.Contains(x.Id)));
 
         AssertSql();
     }
 
-    public override async Task Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant(bool async)
     {
-        await base.Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant();
+        var (_, entityId) = (2, 999);
+
+        await AssertQuery(
+            async,
+            ss => ss.Set<TestEntity>().Where(x => new[] { _, entityId }.Count(i => i > x.Id) == 1));
 
         AssertSql(
 $"""
@@ -549,9 +591,15 @@ SELECT COUNT(*)
 """);
     }
 
-    public override async Task Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant()
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant(bool async)
     {
-        await base.Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant();
+        var (_, entityId) = (2, 999);
+
+        await AssertQuery(
+            async,
+            ss => ss.Set<TestEntity>().Where(x => new[] { _, entityId }.Contains(x.Id)));
 
         AssertSql(
 """
@@ -576,14 +624,21 @@ public override async Task Project_collection_from_entity_type_with_owned()
     public virtual void Check_all_tests_overridden()
         => MySqlTestHelpers.AssertAllMethodsOverridden(GetType());
 
-    protected override DbContextOptionsBuilder SetTranslateParameterizedCollectionsToConstants(DbContextOptionsBuilder optionsBuilder)
+    protected override DbContextOptionsBuilder SetParameterizedCollectionMode(DbContextOptionsBuilder optionsBuilder, ParameterTranslationMode mode)
+    {
+        // MySQL-specific parameter handling configuration
+        // For now, use default MySQL behavior as the implementation is provider-specific
+        return optionsBuilder;
+    }
+
+    protected virtual DbContextOptionsBuilder SetTranslateParameterizedCollectionsToConstants(DbContextOptionsBuilder optionsBuilder)
     {
         new MySqlDbContextOptionsBuilder(optionsBuilder).TranslateParameterizedCollectionsToConstants();
 
         return optionsBuilder;
     }
 
-    protected override DbContextOptionsBuilder SetTranslateParameterizedCollectionsToParameters(DbContextOptionsBuilder optionsBuilder)
+    protected virtual DbContextOptionsBuilder SetTranslateParameterizedCollectionsToParameters(DbContextOptionsBuilder optionsBuilder)
     {
         new MySqlDbContextOptionsBuilder(optionsBuilder).TranslateParameterizedCollectionsToParameters();