Tests : A better infrastructure for asserting includes in the query (#…

…20958)

Remove AssertIncludeQuery which is based on queryable
Introduce AssertInclude method over element which can be used anywhere element asserter can be passed just like collection asserter

Resolves #15368

test/EFCore.Specification.Tests/Query/NorthwindNavigationsQueryTestBase.cs

@@ -306,31 +306,31 @@ where o2.CustomerID.StartsWith("A")
         [MemberData(nameof(IsAsyncData))]
         public virtual Task Select_Where_Navigation_Included(bool async)
         {
-            return AssertIncludeQuery(
+            return AssertQuery(
                 async,
                 ss => from o in ss.Set<Order>().Include(o => o.Customer)
                       where o.Customer.City == "Seattle"
                       select o,
-                new List<IExpectedInclude> { new ExpectedInclude<Order>(o => o.Customer) },
+                elementAsserter: (e, a) => AssertInclude(e, a, new ExpectedInclude<Order>(o => o.Customer)),
                 entryCount: 15);
         }
 
         [ConditionalTheory]
         [MemberData(nameof(IsAsyncData))]
         public virtual Task Include_with_multiple_optional_navigations(bool async)
         {
-            var expectedIncludes = new List<IExpectedInclude>
+            var expectedIncludes = new IExpectedInclude[]
             {
                 new ExpectedInclude<OrderDetail>(od => od.Order),
                 new ExpectedInclude<Order>(o => o.Customer, "Order")
             };
 
-            return AssertIncludeQuery(
+            return AssertQuery(
                 async,
                 ss => ss.Set<OrderDetail>()
                     .Include(od => od.Order.Customer)
                     .Where(od => od.Order.Customer.City == "London"),
-                expectedIncludes,
+                elementAsserter: (e, a) => AssertInclude(e, a, expectedIncludes),
                 entryCount: 164);
         }
 
@@ -985,7 +985,7 @@ public virtual void Navigation_in_subquery_referencing_outer_query()
         {
             using var context = CreateContext();
             var query = from o in context.Orders
-                        // ReSharper disable once UseMethodAny.0
+                            // ReSharper disable once UseMethodAny.0
                         where (from od in context.OrderDetails
                                where o.Customer.Country == od.Order.Customer.Country
                                select od).Count()

test/EFCore.Specification.Tests/Query/QueryTestBase.cs

@@ -80,47 +80,6 @@ public Task AssertQueryScalar<TResult>(
             where TResult : struct
             => Fixture.QueryAsserter.AssertQueryScalar(actualQuery, expectedQuery, assertOrder, async, testMethodName);
 
-        public Task<List<TResult>> AssertIncludeQuery<TResult>(
-            bool async,
-            Func<ISetSource, IQueryable<TResult>> query,
-            List<IExpectedInclude> expectedIncludes,
-            Func<TResult, object> elementSorter = null,
-            List<Func<TResult, object>> clientProjections = null,
-            bool assertOrder = false,
-            int entryCount = 0,
-            [CallerMemberName] string testMethodName = null)
-            => AssertIncludeQuery(
-                async,
-                query,
-                query,
-                expectedIncludes,
-                elementSorter,
-                clientProjections,
-                assertOrder,
-                entryCount,
-                testMethodName);
-
-        public Task<List<TResult>> AssertIncludeQuery<TResult>(
-            bool async,
-            Func<ISetSource, IQueryable<TResult>> actualQuery,
-            Func<ISetSource, IQueryable<TResult>> expectedQuery,
-            List<IExpectedInclude> expectedIncludes,
-            Func<TResult, object> elementSorter = null,
-            List<Func<TResult, object>> clientProjections = null,
-            bool assertOrder = false,
-            int entryCount = 0,
-            [CallerMemberName] string testMethodName = null)
-            => Fixture.QueryAsserter.AssertIncludeQuery(
-                actualQuery,
-                expectedQuery,
-                expectedIncludes,
-                elementSorter,
-                clientProjections,
-                assertOrder,
-                entryCount,
-                async,
-                testMethodName);
-
         protected Task AssertSingleResult<TResult>(
             bool async,
             Expression<Func<ISetSource, TResult>> syncQuery,
@@ -1117,6 +1076,12 @@ protected void AssertCollection<TElement>(
             Action<TElement, TElement> elementAsserter = null)
             => Fixture.QueryAsserter.AssertCollection(expected, actual, ordered, elementSorter, elementAsserter);
 
+        protected void AssertInclude<TEntity>(
+            TEntity expected,
+            TEntity actual,
+            params IExpectedInclude[] expectedIncludes)
+            => Fixture.QueryAsserter.AssertInclude(expected, actual, expectedIncludes);
+
         protected void AssertGrouping<TKey, TElement>(
             IGrouping<TKey, TElement> expected,
             IGrouping<TKey, TElement> actual,

test/EFCore.Specification.Tests/TestUtilities/QueryAsserter.cs

@@ -212,69 +212,6 @@ public override async Task AssertQueryScalar<TResult>(
                 assertOrder);
         }
 
-        public override async Task<List<TResult>> AssertIncludeQuery<TResult>(
-            Func<ISetSource, IQueryable<TResult>> actualQuery,
-            Func<ISetSource, IQueryable<TResult>> expectedQuery,
-            List<IExpectedInclude> expectedIncludes,
-            Func<TResult, object> elementSorter,
-            List<Func<TResult, object>> clientProjections,
-            bool assertOrder,
-            int entryCount,
-            bool async,
-            string testMethodName)
-        {
-            using var context = _contextCreator();
-            var query = actualQuery(SetSourceCreator(context));
-            if (ProceduralQueryGeneration && !async)
-            {
-                new ProcedurallyGeneratedQueryExecutor().Execute(query, context, testMethodName);
-
-                return default;
-            }
-
-            OrderingSettingsVerifier(assertOrder, query.Expression.Type, elementSorter);
-
-            var actual = async
-                ? await query.ToListAsync()
-                : query.ToList();
-
-            AssertRogueExecution(actual.Count, query);
-
-            var expected = GetExpectedResults(expectedQuery).ToList();
-
-            if (!assertOrder
-                && elementSorter == null)
-            {
-                _entitySorters.TryGetValue(typeof(TResult), out var sorter);
-                elementSorter = (Func<TResult, object>)sorter;
-            }
-
-            if (elementSorter != null)
-            {
-                actual = actual.OrderBy(elementSorter).ToList();
-                expected = expected.OrderBy(elementSorter).ToList();
-            }
-
-            if (clientProjections != null)
-            {
-                foreach (var clientProjection in clientProjections)
-                {
-                    var projectedActual = actual.Select(clientProjection).ToList();
-                    var projectedExpected = expected.Select(clientProjection).ToList();
-
-                    _includeResultAsserter.AssertResult(projectedExpected, projectedActual, expectedIncludes);
-                }
-            }
-            else
-            {
-                _includeResultAsserter.AssertResult(expected, actual, expectedIncludes);
-            }
-
-            Assert.Equal(entryCount, context.ChangeTracker.Entries().Count());
-
-            return actual;
-        }
-
         #region Assert termination operation methods
 
         public override async Task AssertAny<TResult>(
@@ -1551,6 +1488,9 @@ public override void AssertCollection<TElement>(
             }
         }
 
+        public override void AssertInclude<TEntity>(TEntity expected, TEntity actual, IExpectedInclude[] expectedIncludes)
+            => _includeResultAsserter.AssertResult(expected, actual, expectedIncludes);
+
         #endregion
 
         private class DefaultSetSource : ISetSource

test/EFCore.Specification.Tests/TestUtilities/QueryAsserterBase.cs

@@ -51,17 +51,6 @@ public abstract Task AssertQueryScalar<TResult>(
             string testMethodName)
             where TResult : struct;
 
-        public abstract Task<List<TResult>> AssertIncludeQuery<TResult>(
-            Func<ISetSource, IQueryable<TResult>> actualQuery,
-            Func<ISetSource, IQueryable<TResult>> expectedQuery,
-            List<IExpectedInclude> expectedIncludes,
-            Func<TResult, object> elementSorter,
-            List<Func<TResult, object>> clientProjections,
-            bool assertOrder,
-            int entryCount,
-            bool async,
-            string testMethodName);
-
         #region Assert termination operation methods
 
         public abstract Task AssertAny<TResult>(
@@ -537,6 +526,11 @@ public abstract void AssertCollection<TElement>(
             Func<TElement, object> elementSorter = null,
             Action<TElement, TElement> elementAsserter = null);
 
+        public abstract void AssertInclude<TEntity>(
+            TEntity expected,
+            TEntity actual,
+            IExpectedInclude[] expectedIncludes);
+
         #endregion
     }
 }

test/EFCore.Specification.Tests/TestUtilities/TestHelpers.cs

@@ -208,22 +208,18 @@ public static int AssertResults<T>(
             Assert.Equal(expected.Count, actual.Count);
 
             if (elementSorter == null
-                && !verifyOrdered)
+                && !verifyOrdered
+                && expected.Count > 1 // If there is only 1 element then sorting is not necessary
+                && expected.FirstOrDefault(e => e != null) is T nonNullElement
+                    && nonNullElement.GetType().GetInterface(nameof(IComparable)) == null)
             {
-                if (expected.Count > 1)
+                if (elementAsserter != null)
                 {
-                    if (expected.FirstOrDefault(e => e != null) is T nonNullElement
-                        && nonNullElement.GetType().GetInterface(nameof(IComparable)) == null)
-                    {
-                        if (elementAsserter != null)
-                        {
-                            throw new InvalidOperationException(
-                                "Element asserter will not be used because results are not properly ordered - either remove asserter from the AssertQuery, add element sorter or set assertOrder to 'true'.");
-                        }
-
-                        return AssertResults(expected, actual);
-                    }
+                    throw new InvalidOperationException(
+                        "Element asserter will not be used because results are not properly ordered - either remove asserter from the AssertQuery, add element sorter or set assertOrder to 'true'.");
                 }
+
+                return AssertResults(expected, actual);
             }
 
             elementSorter ??= (e => e);

test/EFCore.SqlServer.FunctionalTests/Query/GearsOfWarQuerySqlServerTest.cs

@@ -4839,22 +4839,6 @@ FROM [Gears] AS [g]
 ) AS [t0] ON [s].[Id] = [t0].[SquadId]");
         }
 
-        public override async Task Include_with_order_by_constant_null_of_non_mapped_type(bool async)
-        {
-            await base.Include_with_order_by_constant_null_of_non_mapped_type(async);
-
-            AssertSql(
-                "");
-        }
-
-        public override void Include_groupby_constant_null_of_non_mapped_type()
-        {
-            base.Include_groupby_constant_null_of_non_mapped_type();
-
-            AssertSql(
-                "");
-        }
-
         public override async Task Include_collection_OrderBy_aggregate(bool async)
         {
             await base.Include_collection_OrderBy_aggregate(async);