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

src/EFCore/Infrastructure/ModelValidator.cs

@@ -1018,6 +1018,18 @@ protected virtual void ValidateQueryFilters(
                     }
                 }
 
+
+                if (entityType.ClrType.Name.Contains("OrderDetail"))
+                {
+                    var n = entityType.GetNavigations().First();
+                    var a1 = n.IsCollection;
+                    var a2 = n.ForeignKey.IsRequired;
+                    var a3 = n.IsOnDependent;
+                    var a4 = n.ForeignKey.PrincipalEntityType.GetQueryFilter() != null;
+                    var a5 = n.ForeignKey.DeclaringEntityType.GetQueryFilter() == null;
+
+                }
+
                 var requiredNavigationWithQueryFilter = entityType.GetNavigations()
                     .Where(
                         n => !n.IsCollection

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,8 +15,20 @@ public abstract class NullSemanticsQueryFixtureBase : SharedStoreFixtureBase<Nul
         public Func<DbContext> GetContextCreator()
             => () => CreateContext();
 
-        public ISetSource GetExpectedData()
-            => new NullSemanticsData();
+        private readonly Dictionary<bool, ISetSource> _expectedDataCache = new Dictionary<bool, ISetSource>();
+
+        public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters)
+        {
+            if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult))
+            {
+                return cachedResult;
+            }
+
+            var expectedData = new NullSemanticsData();
+            _expectedDataCache[applyFilters] = expectedData;
+
+            return expectedData;
+        }
 
         public IReadOnlyDictionary<Type, object> GetEntitySorters()
             => new Dictionary<Type, Func<object, object>>

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

@@ -18,8 +18,20 @@ public abstract class ComplexNavigationsQueryFixtureBase : SharedStoreFixtureBas
         public Func<DbContext> GetContextCreator()
             => () => CreateContext();
 
-        public virtual ISetSource GetExpectedData()
-            => new ComplexNavigationsDefaultData();
+        private readonly Dictionary<bool, ISetSource> _expectedDataCache = new Dictionary<bool, ISetSource>();
+
+        public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters)
+        {
+            if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult))
+            {
+                return cachedResult;
+            }
+
+            var expectedData = new ComplexNavigationsDefaultData();
+            _expectedDataCache[applyFilters] = expectedData;
+
+            return expectedData;
+        }
 
         public IReadOnlyDictionary<Type, object> GetEntitySorters()
             => new Dictionary<Type, Func<object, object>>

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(ctx, applyFilters: false).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;
@@ -15,8 +16,20 @@ public abstract class ComplexNavigationsWeakQueryFixtureBase : ComplexNavigation
     {
         protected override string StoreName { get; } = "ComplexNavigationsOwned";
 
-        public override ISetSource GetExpectedData()
-            => new ComplexNavigationsWeakData();
+        private readonly Dictionary<bool, ISetSource> _expectedDataCache = new Dictionary<bool, ISetSource>();
+
+        public override ISetSource GetExpectedData(DbContext context, bool applyFilters)
+        {
+            if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult))
+            {
+                return cachedResult;
+            }
+
+            var expectedData = new ComplexNavigationsWeakData();
+            _expectedDataCache[applyFilters] = expectedData;
+
+            return expectedData;
+        }
 
         Func<DbContext, ISetSource> IQueryFixtureBase.GetSetSourceCreator()
             => context => new ComplexNavigationsWeakSetExtractor(context);

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