Fix to #21393 - Query: Convert to AssertQuery in tests as much as possible

test/EFCore.Relational.Specification.Tests/Query/ManyToManyNoTrackingQueryRelationalTestBase.cs

@@ -303,6 +303,10 @@ public virtual Task Filtered_include_on_navigation_then_filtered_include_on_skip
 
         protected override QueryAsserter CreateQueryAsserter(TFixture fixture)
             => new RelationalQueryAsserter(
-                fixture, RewriteExpectedQueryExpression, RewriteServerQueryExpression, IgnoreEntryCount, CanExecuteQueryString);
+                fixture,
+                RewriteExpectedQueryExpression,
+                RewriteServerQueryExpression,
+                ignoreEntryCount: IgnoreEntryCount,
+                canExecuteQueryString: CanExecuteQueryString);
     }
 }

test/EFCore.Relational.Specification.Tests/Query/ManyToManyQueryRelationalTestBase.cs

@@ -322,6 +322,10 @@ public virtual Task Filtered_include_on_navigation_then_filtered_include_on_skip
 
         protected override QueryAsserter CreateQueryAsserter(TFixture fixture)
             => new RelationalQueryAsserter(
-                fixture, RewriteExpectedQueryExpression, RewriteServerQueryExpression, IgnoreEntryCount, CanExecuteQueryString);
+                fixture,
+                RewriteExpectedQueryExpression,
+                RewriteServerQueryExpression,
+                ignoreEntryCount: IgnoreEntryCount,
+                canExecuteQueryString: CanExecuteQueryString);
     }
 }

test/EFCore.Relational.Specification.Tests/Query/NorthwindAggregateOperatorsQueryRelationalTestBase.cs

@@ -39,6 +39,9 @@ protected virtual bool CanExecuteQueryString
 
         protected override QueryAsserter CreateQueryAsserter(TFixture fixture)
             => new RelationalQueryAsserter(
-                fixture, RewriteExpectedQueryExpression, RewriteServerQueryExpression, canExecuteQueryString: CanExecuteQueryString);
+                fixture,
+                RewriteExpectedQueryExpression,
+                RewriteServerQueryExpression,
+                canExecuteQueryString: CanExecuteQueryString);
     }
 }

test/EFCore.Relational.Specification.Tests/Query/NullSemanticsQueryFixtureBase.cs

@@ -15,7 +15,7 @@ public abstract class NullSemanticsQueryFixtureBase : SharedStoreFixtureBase<Nul
         public Func<DbContext> GetContextCreator()
             => () => CreateContext();
 
-        public ISetSource GetExpectedData()
+        public virtual ISetSource GetExpectedData()
             => new NullSemanticsData();
 
         public IReadOnlyDictionary<Type, object> GetEntitySorters()

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

@@ -4905,7 +4905,7 @@ public virtual void Contains_over_optional_navigation_with_null_constant()
         {
             using var ctx = CreateContext();
             var result = ctx.Set<Level1>().Select(l1 => l1.OneToOne_Optional_FK1).Contains(null);
-            var expected = QueryAsserter.ExpectedData.Set<Level1>().Select(l1 => l1.OneToOne_Optional_FK1).Contains(null);
+            var expected = Fixture.GetExpectedData().Set<Level1>().Select(l1 => l1.OneToOne_Optional_FK1).Contains(null);
 
             Assert.Equal(expected, result);
         }
@@ -5394,19 +5394,31 @@ await Assert.ThrowsAsync<InvalidOperationException>(
                         .Select(l1 => ss.Set<Level2>().Include(l2 => l2.OneToMany_Optional2.Where(x => x.Id != l2.Id)))));
         }
 
-        [ConditionalFact]
-        public virtual void Filtered_include_outer_parameter_used_inside_filter()
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Filtered_include_outer_parameter_used_inside_filter(bool async)
         {
-            // TODO: needs #18191 for result verification
-            using var ctx = CreateContext();
-            var query = ctx.LevelOne.Select(
+            return AssertQuery(
+                async,
+                ss => ss.Set<Level1>().Select(
                 l1 => new
                 {
                     l1.Id,
-                    FullInclude = ctx.LevelTwo.Include(l2 => l2.OneToMany_Optional2).ToList(),
-                    FilteredInclude = ctx.LevelTwo.Include(l2 => l2.OneToMany_Optional2.Where(x => x.Id != l1.Id)).ToList()
+                    FullInclude = ss.Set<Level2>().Include(l2 => l2.OneToMany_Optional2).ToList(),
+                    FilteredInclude = ss.Set<Level2>().Include(l2 => l2.OneToMany_Optional2.Where(x => x.Id != l1.Id)).ToList()
+                }),
+                elementSorter: e => e.Id,
+                elementAsserter: (e, a) =>
+                {
+                    Assert.Equal(e.Id, a.Id);
+                    AssertInclude(e.FullInclude, a.FullInclude, new ExpectedInclude<Level2>(x => x.OneToMany_Optional2));
+                    AssertInclude(
+                        e.FilteredInclude,
+                        a.FilteredInclude,
+                        new ExpectedFilteredInclude<Level2, Level3>(
+                            x => x.OneToMany_Optional2,
+                            includeFilter: x => x.Where(x => x.Id != e.Id)));
                 });
-            var result = query.ToList();
         }
 
         [ConditionalFact]

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

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;

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

@@ -177,9 +177,10 @@ public override Task Include_inside_subquery(bool async)
             return base.Include_inside_subquery(async);
         }
 
-        public override void Filtered_include_outer_parameter_used_inside_filter()
+        [ConditionalTheory(Skip = "Issue#16752")]
+        public override Task Filtered_include_outer_parameter_used_inside_filter(bool async)
         {
-            // TODO: this test can be ran with weak entities once #18191 is fixed and we can use query test infra properly
+            return base.Filtered_include_outer_parameter_used_inside_filter(async);
         }
 
         [ConditionalTheory(Skip = "Issue#17803")]

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

@@ -0,0 +1,72 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.TestUtilities;
+
+namespace Microsoft.EntityFrameworkCore.Query
+{
+    public abstract class FilteredQueryTestBase<TFixture> : QueryTestBase<TFixture>
+        where TFixture : class, IQueryFixtureBase, new()
+    {
+        protected FilteredQueryTestBase(TFixture fixture)
+            : base(fixture)
+        {
+        }
+
+        public Task AssertFilteredQuery<TResult>(
+            bool async,
+            Func<ISetSource, IQueryable<TResult>> query,
+            Func<TResult, object> elementSorter = null,
+            Action<TResult, TResult> elementAsserter = null,
+            bool assertOrder = false,
+            int entryCount = 0,
+            [CallerMemberName] string testMethodName = null)
+            where TResult : class
+            => AssertFilteredQuery(async, query, query, elementSorter, elementAsserter, assertOrder, entryCount, testMethodName);
+
+        public Task AssertFilteredQuery<TResult>(
+            bool async,
+            Func<ISetSource, IQueryable<TResult>> actualQuery,
+            Func<ISetSource, IQueryable<TResult>> expectedQuery,
+            Func<TResult, object> elementSorter = null,
+            Action<TResult, TResult> elementAsserter = null,
+            bool assertOrder = false,
+            int entryCount = 0,
+            [CallerMemberName] string testMethodName = null)
+            where TResult : class
+            => QueryAsserter.AssertQuery(
+                actualQuery, expectedQuery, elementSorter, elementAsserter, assertOrder, entryCount, async, testMethodName, filteredQuery: true);
+
+        public Task AssertFilteredQueryScalar<TResult>(
+            bool async,
+            Func<ISetSource, IQueryable<TResult>> query,
+            bool assertOrder = false,
+            [CallerMemberName] string testMethodName = null)
+            where TResult : struct
+            => AssertFilteredQueryScalar(async, query, query, assertOrder, testMethodName);
+
+        public Task AssertFilteredQueryScalar<TResult>(
+            bool async,
+            Func<ISetSource, IQueryable<TResult>> actualQuery,
+            Func<ISetSource, IQueryable<TResult>> expectedQuery,
+            bool assertOrder = false,
+            [CallerMemberName] string testMethodName = null)
+            where TResult : struct
+            => QueryAsserter.AssertQueryScalar(actualQuery, expectedQuery, assertOrder, async, testMethodName, filteredQuery: true);
+
+        protected Task AssertFilteredCount<TResult>(
+            bool async,
+            Func<ISetSource, IQueryable<TResult>> query)
+            => AssertFilteredCount(async, query, query);
+
+        protected Task AssertFilteredCount<TResult>(
+            bool async,
+            Func<ISetSource, IQueryable<TResult>> actualQuery,
+            Func<ISetSource, IQueryable<TResult>> expectedQuery)
+            => QueryAsserter.AssertCount(actualQuery, expectedQuery, async, filteredQuery: true);
+    }
+}