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

…sible

added support for query filters to the AssertQuery test infra (using AssertFilteredQuery methods) and converted query filter tests to take advantage of it
- when creating new instance of ExpectedData we can now apply necessary filtering direcly on the dataset, rather than modifying the expected query itself,
- ExpectedData is now created for every query to make sure changes to properties on dbcontext are taken into account (e.g. TenantId),
- ExpectedData are cached to avoid big perf hit.

Also incorporated async GoW tests into the regular GoW test suite,

Fixes #21393

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);
+    }
+}