From 7401b7e75b43fcf8c7e1a671fa9569005ef6a7dd Mon Sep 17 00:00:00 2001 From: maumar Date: Tue, 13 Oct 2020 20:19:51 -0700 Subject: [PATCH] Fix to #21393 - Query: Convert to AssertQuery in tests as much as possible 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 --- .../Query/AsyncGearsOfWarQueryInMemoryTest.cs | 15 - .../AsyncGearsOfWarQueryRelationalTestBase.cs | 23 - ...ToManyNoTrackingQueryRelationalTestBase.cs | 6 +- .../ManyToManyQueryRelationalTestBase.cs | 6 +- ...gregateOperatorsQueryRelationalTestBase.cs | 5 +- .../Query/NullSemanticsQueryFixtureBase.cs | 16 +- .../Query/AsyncGearsOfWarQueryTestBase.cs | 48 -- .../ComplexNavigationsQueryFixtureBase.cs | 16 +- .../Query/ComplexNavigationsQueryTestBase.cs | 30 +- .../ComplexNavigationsWeakQueryFixtureBase.cs | 17 +- .../ComplexNavigationsWeakQueryTestBase.cs | 5 +- .../Query/FilteredQueryTestBase.cs | 72 +++ .../Query/FiltersInheritanceQueryTestBase.cs | 186 ++++---- .../Query/FunkyDataQueryTestBase.cs | 16 +- .../Query/GearsOfWarQueryFixtureBase.cs | 16 +- .../Query/GearsOfWarQueryTestBase.cs | 18 + .../Query/IQueryFixtureBase.cs | 2 +- .../Query/InheritanceQueryFixtureBase.cs | 23 +- ...nheritanceRelationshipsQueryFixtureBase.cs | 16 +- .../Query/ManyToManyQueryFixtureBase.cs | 16 +- .../NorthwindMiscellaneousQueryTestBase.cs | 14 +- .../NorthwindQueryFiltersQueryTestBase.cs | 249 ++++++---- .../Query/NorthwindQueryFixtureBase.cs | 55 ++- .../Query/OwnedQueryTestBase.cs | 21 +- .../Query/QueryTestBase.cs | 6 +- .../Query/SpatialQueryFixtureBase.cs | 16 +- .../InheritanceModel/InheritanceData.cs | 16 +- .../TestModels/Northwind/NorthwindContext.cs | 2 +- .../TestModels/Northwind/NorthwindData.cs | 89 ++-- .../TestUtilities/QueryAsserter.cs | 443 ++++++++++++------ .../AsyncGearsOfWarQuerySqlServerTest.cs | 20 - .../ComplexNavigationsQuerySqlServerTest.cs | 4 +- .../FiltersInheritanceQuerySqlServerTest.cs | 47 +- ...NorthwindQueryFiltersQuerySqlServerTest.cs | 71 +-- ...TPTFiltersInheritanceQuerySqlServerTest.cs | 49 +- .../Query/AsyncGearsOfWarQuerySqliteTest.cs | 17 - .../ComplexNavigationsQuerySqliteTest.cs | 6 +- .../NorthwindQueryFiltersQuerySqliteTest.cs | 5 +- 38 files changed, 1079 insertions(+), 603 deletions(-) delete mode 100644 test/EFCore.InMemory.FunctionalTests/Query/AsyncGearsOfWarQueryInMemoryTest.cs delete mode 100644 test/EFCore.Relational.Specification.Tests/Query/AsyncGearsOfWarQueryRelationalTestBase.cs delete mode 100644 test/EFCore.Specification.Tests/Query/AsyncGearsOfWarQueryTestBase.cs create mode 100644 test/EFCore.Specification.Tests/Query/FilteredQueryTestBase.cs delete mode 100644 test/EFCore.SqlServer.FunctionalTests/Query/AsyncGearsOfWarQuerySqlServerTest.cs delete mode 100644 test/EFCore.Sqlite.FunctionalTests/Query/AsyncGearsOfWarQuerySqliteTest.cs diff --git a/test/EFCore.InMemory.FunctionalTests/Query/AsyncGearsOfWarQueryInMemoryTest.cs b/test/EFCore.InMemory.FunctionalTests/Query/AsyncGearsOfWarQueryInMemoryTest.cs deleted file mode 100644 index 564449e3c3f..00000000000 --- a/test/EFCore.InMemory.FunctionalTests/Query/AsyncGearsOfWarQueryInMemoryTest.cs +++ /dev/null @@ -1,15 +0,0 @@ -// 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 Xunit.Abstractions; - -namespace Microsoft.EntityFrameworkCore.Query -{ - public class AsyncGearsOfWarQueryInMemoryTest : AsyncGearsOfWarQueryTestBase - { - public AsyncGearsOfWarQueryInMemoryTest(GearsOfWarQueryInMemoryFixture fixture, ITestOutputHelper testOutputHelper) - : base(fixture) - { - } - } -} diff --git a/test/EFCore.Relational.Specification.Tests/Query/AsyncGearsOfWarQueryRelationalTestBase.cs b/test/EFCore.Relational.Specification.Tests/Query/AsyncGearsOfWarQueryRelationalTestBase.cs deleted file mode 100644 index 631e309d4e9..00000000000 --- a/test/EFCore.Relational.Specification.Tests/Query/AsyncGearsOfWarQueryRelationalTestBase.cs +++ /dev/null @@ -1,23 +0,0 @@ -// 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 Microsoft.EntityFrameworkCore.TestUtilities; - -namespace Microsoft.EntityFrameworkCore.Query -{ - public abstract class AsyncGearsOfWarQueryRelationalTestBase : AsyncGearsOfWarQueryTestBase - where TFixture : GearsOfWarQueryFixtureBase, new() - { - protected AsyncGearsOfWarQueryRelationalTestBase(TFixture fixture) - : base(fixture) - { - } - - protected virtual bool CanExecuteQueryString - => false; - - protected override QueryAsserter CreateQueryAsserter(TFixture fixture) - => new RelationalQueryAsserter( - fixture, RewriteExpectedQueryExpression, RewriteServerQueryExpression, canExecuteQueryString: CanExecuteQueryString); - } -} diff --git a/test/EFCore.Relational.Specification.Tests/Query/ManyToManyNoTrackingQueryRelationalTestBase.cs b/test/EFCore.Relational.Specification.Tests/Query/ManyToManyNoTrackingQueryRelationalTestBase.cs index be7ca87caa4..b48ae93f9b2 100644 --- a/test/EFCore.Relational.Specification.Tests/Query/ManyToManyNoTrackingQueryRelationalTestBase.cs +++ b/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); } } diff --git a/test/EFCore.Relational.Specification.Tests/Query/ManyToManyQueryRelationalTestBase.cs b/test/EFCore.Relational.Specification.Tests/Query/ManyToManyQueryRelationalTestBase.cs index f686aa690bb..8920b668049 100644 --- a/test/EFCore.Relational.Specification.Tests/Query/ManyToManyQueryRelationalTestBase.cs +++ b/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); } } diff --git a/test/EFCore.Relational.Specification.Tests/Query/NorthwindAggregateOperatorsQueryRelationalTestBase.cs b/test/EFCore.Relational.Specification.Tests/Query/NorthwindAggregateOperatorsQueryRelationalTestBase.cs index e2c4381a99f..38e800f8aa0 100644 --- a/test/EFCore.Relational.Specification.Tests/Query/NorthwindAggregateOperatorsQueryRelationalTestBase.cs +++ b/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); } } diff --git a/test/EFCore.Relational.Specification.Tests/Query/NullSemanticsQueryFixtureBase.cs b/test/EFCore.Relational.Specification.Tests/Query/NullSemanticsQueryFixtureBase.cs index de02e5ae1dd..cadb81c1bd1 100644 --- a/test/EFCore.Relational.Specification.Tests/Query/NullSemanticsQueryFixtureBase.cs +++ b/test/EFCore.Relational.Specification.Tests/Query/NullSemanticsQueryFixtureBase.cs @@ -15,8 +15,20 @@ public abstract class NullSemanticsQueryFixtureBase : SharedStoreFixtureBase GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new NullSemanticsData(); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + 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 GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/AsyncGearsOfWarQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/AsyncGearsOfWarQueryTestBase.cs deleted file mode 100644 index 7d66607882e..00000000000 --- a/test/EFCore.Specification.Tests/Query/AsyncGearsOfWarQueryTestBase.cs +++ /dev/null @@ -1,48 +0,0 @@ -// 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.Threading.Tasks; -using Microsoft.EntityFrameworkCore.TestModels.GearsOfWarModel; -using Xunit; - -// ReSharper disable InconsistentNaming -namespace Microsoft.EntityFrameworkCore.Query -{ - public abstract class AsyncGearsOfWarQueryTestBase : QueryTestBase - where TFixture : GearsOfWarQueryFixtureBase, new() - { - protected AsyncGearsOfWarQueryTestBase(TFixture fixture) - : base(fixture) - { - } - - protected GearsOfWarContext CreateContext() - => Fixture.CreateContext(); - - [ConditionalFact] - public virtual async Task Cast_to_derived_type_causes_client_eval() - { - using var context = CreateContext(); - await Assert.ThrowsAsync( - () => context.Gears.Cast().ToListAsync()); - } - - [ConditionalFact] - public virtual async Task Sum_with_no_data_nullable_double() - { - using var ctx = CreateContext(); - var result = await ctx.Missions.Where(m => m.CodeName == "Operation Foobar").Select(m => m.Rating).SumAsync(); - Assert.Equal(0, result); - } - - [ConditionalFact] - public virtual async Task GroupBy_Select_sum() - { - using var ctx = CreateContext(); - var result = await ctx.Missions.GroupBy(m => m.CodeName).Select(g => g.Sum(m => m.Rating)).ToListAsync(); - Assert.Equal(6.3, result.Sum() ?? double.NaN, precision: 1); - } - } -} diff --git a/test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryFixtureBase.cs index 9553a3c38c9..a78483831ed 100644 --- a/test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryFixtureBase.cs @@ -18,8 +18,20 @@ public abstract class ComplexNavigationsQueryFixtureBase : SharedStoreFixtureBas public Func GetContextCreator() => () => CreateContext(); - public virtual ISetSource GetExpectedData() - => new ComplexNavigationsDefaultData(); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + 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 GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryTestBase.cs index a6bdd41ad31..20f20b9fd02 100644 --- a/test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryTestBase.cs +++ b/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().Select(l1 => l1.OneToOne_Optional_FK1).Contains(null); - var expected = QueryAsserter.ExpectedData.Set().Select(l1 => l1.OneToOne_Optional_FK1).Contains(null); + var expected = Fixture.GetExpectedData(ctx, applyFilters: false).Set().Select(l1 => l1.OneToOne_Optional_FK1).Contains(null); Assert.Equal(expected, result); } @@ -5394,19 +5394,31 @@ await Assert.ThrowsAsync( .Select(l1 => ss.Set().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().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().Include(l2 => l2.OneToMany_Optional2).ToList(), + FilteredInclude = ss.Set().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(x => x.OneToMany_Optional2)); + AssertInclude( + e.FilteredInclude, + a.FilteredInclude, + new ExpectedFilteredInclude( + x => x.OneToMany_Optional2, + includeFilter: x => x.Where(x => x.Id != e.Id))); }); - var result = query.ToList(); } [ConditionalFact] diff --git a/test/EFCore.Specification.Tests/Query/ComplexNavigationsWeakQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/ComplexNavigationsWeakQueryFixtureBase.cs index 64d5facf7a0..110841d3831 100644 --- a/test/EFCore.Specification.Tests/Query/ComplexNavigationsWeakQueryFixtureBase.cs +++ b/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 _expectedDataCache = new Dictionary(); + + 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 IQueryFixtureBase.GetSetSourceCreator() => context => new ComplexNavigationsWeakSetExtractor(context); diff --git a/test/EFCore.Specification.Tests/Query/ComplexNavigationsWeakQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/ComplexNavigationsWeakQueryTestBase.cs index bf277c18112..0793f76b94e 100644 --- a/test/EFCore.Specification.Tests/Query/ComplexNavigationsWeakQueryTestBase.cs +++ b/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")] diff --git a/test/EFCore.Specification.Tests/Query/FilteredQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/FilteredQueryTestBase.cs new file mode 100644 index 00000000000..8f3715ea2d0 --- /dev/null +++ b/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 : QueryTestBase + where TFixture : class, IQueryFixtureBase, new() + { + protected FilteredQueryTestBase(TFixture fixture) + : base(fixture) + { + } + + public Task AssertFilteredQuery( + bool async, + Func> query, + Func elementSorter = null, + Action 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( + bool async, + Func> actualQuery, + Func> expectedQuery, + Func elementSorter = null, + Action 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( + bool async, + Func> query, + bool assertOrder = false, + [CallerMemberName] string testMethodName = null) + where TResult : struct + => AssertFilteredQueryScalar(async, query, query, assertOrder, testMethodName); + + public Task AssertFilteredQueryScalar( + bool async, + Func> actualQuery, + Func> expectedQuery, + bool assertOrder = false, + [CallerMemberName] string testMethodName = null) + where TResult : struct + => QueryAsserter.AssertQueryScalar(actualQuery, expectedQuery, assertOrder, async, testMethodName, filteredQuery: true); + + protected Task AssertFilteredCount( + bool async, + Func> query) + => AssertFilteredCount(async, query, query); + + protected Task AssertFilteredCount( + bool async, + Func> actualQuery, + Func> expectedQuery) + => QueryAsserter.AssertCount(actualQuery, expectedQuery, async, filteredQuery: true); + } +} diff --git a/test/EFCore.Specification.Tests/Query/FiltersInheritanceQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/FiltersInheritanceQueryTestBase.cs index dc1cdc33be2..847df5b5ba1 100644 --- a/test/EFCore.Specification.Tests/Query/FiltersInheritanceQueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/FiltersInheritanceQueryTestBase.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.Linq; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.TestModels.InheritanceModel; using Xunit; @@ -11,143 +12,136 @@ // ReSharper disable ConvertMethodToExpressionBody namespace Microsoft.EntityFrameworkCore.Query { - public abstract class FiltersInheritanceQueryTestBase : IClassFixture + public abstract class FiltersInheritanceQueryTestBase : FilteredQueryTestBase where TFixture : InheritanceQueryFixtureBase, new() { protected FiltersInheritanceQueryTestBase(TFixture fixture) - => Fixture = fixture; - - protected TFixture Fixture { get; } - - [ConditionalFact] - public virtual void Can_use_of_type_animal() + : base(fixture) { - using var context = CreateContext(); - var animals = context.Set().OfType().OrderBy(a => a.Species).ToList(); - - Assert.Single(animals); - Assert.IsType(animals[0]); - Assert.Single(context.ChangeTracker.Entries()); } - [ConditionalFact] - public virtual void Can_use_is_kiwi() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_of_type_animal(bool async) { - using var context = CreateContext(); - var kiwis = context.Set().Where(a => a is Kiwi).ToList(); - - Assert.Single(kiwis); + return AssertFilteredQuery( + async, + ss => ss.Set().OfType().OrderBy(a => a.Species), + assertOrder: true, + entryCount: 1); } - [ConditionalFact] - public virtual void Can_use_is_kiwi_with_other_predicate() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_is_kiwi(bool async) { - using var context = CreateContext(); - var animals = context.Set().Where(a => a is Kiwi && a.CountryId == 1).ToList(); - - Assert.Single(animals); + return AssertFilteredQuery( + async, + ss => ss.Set().Where(a => a is Kiwi), + entryCount: 1); } - [ConditionalFact] - public virtual void Can_use_is_kiwi_in_projection() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_is_kiwi_with_other_predicate(bool async) { - using var context = CreateContext(); - var animals = context.Set().Select(a => a is Kiwi).ToList(); - - Assert.Single(animals); - Assert.Equal(1, animals.Count(a => a)); - Assert.Equal(0, animals.Count(a => !a)); + return AssertFilteredQuery( + async, + ss => ss.Set().Where(a => a is Kiwi && a.CountryId == 1), + entryCount: 1); } - [ConditionalFact] - public virtual void Can_use_of_type_bird() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_is_kiwi_in_projection(bool async) { - using var context = CreateContext(); - var animals = context.Set().OfType().OrderBy(a => a.Species).ToList(); + return AssertFilteredQueryScalar( + async, + ss => ss.Set().Select(a => a is Kiwi)); + } - Assert.Single(animals); - Assert.IsType(animals[0]); - Assert.Single(context.ChangeTracker.Entries()); + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_of_type_bird(bool async) + { + return AssertFilteredQuery( + async, + ss => ss.Set().OfType().OrderBy(a => a.Species), + assertOrder: true, + entryCount: 1); } - [ConditionalFact] - public virtual void Can_use_of_type_bird_predicate() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_of_type_bird_predicate(bool async) { - using var context = CreateContext(); - var animals - = context.Set() + return AssertFilteredQuery( + async, + ss => ss.Set() .Where(a => a.CountryId == 1) .OfType() - .OrderBy(a => a.Species) - .ToList(); - - Assert.Single(animals); - Assert.IsType(animals[0]); - Assert.Single(context.ChangeTracker.Entries()); + .OrderBy(a => a.Species), + assertOrder: true, + entryCount: 1); } - [ConditionalFact] - public virtual void Can_use_of_type_bird_with_projection() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_of_type_bird_with_projection(bool async) { - using var context = CreateContext(); - var animals - = context.Set() + return AssertFilteredQuery( + async, + ss => ss.Set() .OfType() - .Select( - b => new { b.EagleId }) - .ToList(); - - Assert.Single(animals); - Assert.Empty(context.ChangeTracker.Entries()); + .Select(b => new { b.EagleId }), + elementSorter: e => e.EagleId); } - [ConditionalFact] - public virtual void Can_use_of_type_bird_first() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_of_type_bird_first(bool async) { - using var context = CreateContext(); - var bird = context.Set().OfType().OrderBy(a => a.Species).First(); - - Assert.NotNull(bird); - Assert.IsType(bird); - Assert.Single(context.ChangeTracker.Entries()); + return AssertFirst( + async, + ss => ss.Set().OfType().OrderBy(a => a.Species), + entryCount: 1); } - [ConditionalFact] - public virtual void Can_use_of_type_kiwi() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_of_type_kiwi(bool async) { - using var context = CreateContext(); - var animals = context.Set().OfType().ToList(); - - Assert.Single(animals); - Assert.IsType(animals[0]); - Assert.Single(context.ChangeTracker.Entries()); + return AssertFilteredQuery( + async, + ss => ss.Set().OfType(), + entryCount: 1); } - [ConditionalFact] - public virtual void Can_use_derived_set() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Can_use_derived_set(bool async) { - using var context = CreateContext(); - var eagles = context.Set().ToList(); - - Assert.Empty(eagles); - Assert.Empty(context.ChangeTracker.Entries()); + return AssertFilteredQuery( + async, + ss => ss.Set()); } - [ConditionalFact] - public virtual void Can_use_IgnoreQueryFilters_and_GetDatabaseValues() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Can_use_IgnoreQueryFilters_and_GetDatabaseValues(bool async) { - using var context = CreateContext(); + using var context = Fixture.CreateContext(); var eagle = context.Set().IgnoreQueryFilters().Single(); Assert.Single(context.ChangeTracker.Entries()); - Assert.NotNull(context.Entry(eagle).GetDatabaseValues()); - } - - protected InheritanceContext CreateContext() - => Fixture.CreateContext(); - - protected virtual void ClearLog() - { + if (async) + { + Assert.NotNull(await context.Entry(eagle).GetDatabaseValuesAsync()); + } + else + { + Assert.NotNull(context.Entry(eagle).GetDatabaseValues()); + } } } } diff --git a/test/EFCore.Specification.Tests/Query/FunkyDataQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/FunkyDataQueryTestBase.cs index 1cdf85230e2..c5ef27f8dc3 100644 --- a/test/EFCore.Specification.Tests/Query/FunkyDataQueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/FunkyDataQueryTestBase.cs @@ -546,8 +546,20 @@ public abstract class FunkyDataQueryFixtureBase : SharedStoreFixtureBase GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new FunkyDataData(); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new FunkyDataData(); + _expectedDataCache[applyFilters] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => new Dictionary> { { typeof(FunkyCustomer), e => ((FunkyCustomer)e)?.Id } } diff --git a/test/EFCore.Specification.Tests/Query/GearsOfWarQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/GearsOfWarQueryFixtureBase.cs index 107c59d47bc..5474dc48295 100644 --- a/test/EFCore.Specification.Tests/Query/GearsOfWarQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/GearsOfWarQueryFixtureBase.cs @@ -18,8 +18,20 @@ public abstract class GearsOfWarQueryFixtureBase : SharedStoreFixtureBase GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new GearsOfWarData(); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new GearsOfWarData(); + _expectedDataCache[applyFilters] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs index fc693cbc27b..5474b011ee9 100644 --- a/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs @@ -7941,6 +7941,24 @@ public virtual Task Correlated_collection_take(bool async) }); } + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task GroupBy_Select_sum(bool async) + { + return AssertQueryScalar( + async, + ss => ss.Set().GroupBy(m => m.CodeName).Select(g => g.Sum(m => m.Rating))); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Sum_with_no_data_nullable_double(bool async) + { + return AssertSum( + async, + ss => ss.Set().Where(m => m.CodeName == "Operation Foobar").Select(m => m.Rating)); + } + protected GearsOfWarContext CreateContext() => Fixture.CreateContext(); diff --git a/test/EFCore.Specification.Tests/Query/IQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/IQueryFixtureBase.cs index fdd604393a7..7172a8b78b1 100644 --- a/test/EFCore.Specification.Tests/Query/IQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/IQueryFixtureBase.cs @@ -15,7 +15,7 @@ public interface IQueryFixtureBase Func GetSetSourceCreator() => context => new DefaultSetSource(context); - ISetSource GetExpectedData(); + ISetSource GetExpectedData(DbContext context, bool applyFilters); IReadOnlyDictionary GetEntitySorters(); diff --git a/test/EFCore.Specification.Tests/Query/InheritanceQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/InheritanceQueryFixtureBase.cs index 3782bf9303f..d5fb560043f 100644 --- a/test/EFCore.Specification.Tests/Query/InheritanceQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/InheritanceQueryFixtureBase.cs @@ -12,6 +12,8 @@ namespace Microsoft.EntityFrameworkCore.Query { public abstract class InheritanceQueryFixtureBase : SharedStoreFixtureBase, IQueryFixtureBase { + private readonly Dictionary _expectedDataCache = new Dictionary(); + protected override string StoreName { get; } = "InheritanceTest"; protected virtual bool EnableFilters @@ -26,8 +28,25 @@ protected virtual bool HasDiscriminator public Func GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new InheritanceData(); + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new InheritanceData(); + if (applyFilters && EnableFilters) + { + var animals = expectedData.Animals.Where(a => a.CountryId == 1).ToList(); + var animalQueries = expectedData.AnimalQueries.Where(a => a.CountryId == 1).ToList(); + expectedData = new InheritanceData(animals, animalQueries, expectedData.Countries, expectedData.Drinks, expectedData.Plants); + } + + _expectedDataCache[applyFilters] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/InheritanceRelationshipsQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/InheritanceRelationshipsQueryFixtureBase.cs index 3fd6a429442..ff5e2f3c134 100644 --- a/test/EFCore.Specification.Tests/Query/InheritanceRelationshipsQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/InheritanceRelationshipsQueryFixtureBase.cs @@ -18,8 +18,20 @@ public abstract class InheritanceRelationshipsQueryFixtureBase : SharedStoreFixt public Func GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new InheritanceRelationshipsData(); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new InheritanceRelationshipsData(); + _expectedDataCache[applyFilters] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/ManyToManyQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/ManyToManyQueryFixtureBase.cs index aac3a89a346..82a523ca4c8 100644 --- a/test/EFCore.Specification.Tests/Query/ManyToManyQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/ManyToManyQueryFixtureBase.cs @@ -17,8 +17,20 @@ public abstract class ManyToManyQueryFixtureBase : SharedStoreFixtureBase GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new ManyToManyData(); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new ManyToManyData(); + _expectedDataCache[applyFilters] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/NorthwindMiscellaneousQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/NorthwindMiscellaneousQueryTestBase.cs index 4c6123e82f2..5e512255bef 100644 --- a/test/EFCore.Specification.Tests/Query/NorthwindMiscellaneousQueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/NorthwindMiscellaneousQueryTestBase.cs @@ -1385,7 +1385,7 @@ public virtual void Select_DTO_distinct_translated_to_server() .Select(o => new OrderCountDTO()) .Distinct().ToList().OrderBy(e => e.Id).ToList(); - var expected = QueryAsserter.ExpectedData.Set() + var expected = Fixture.GetExpectedData(context, applyFilters: false).Set() .Where(o => o.OrderID < 10300) .Select(o => new OrderCountDTO()) .Distinct().ToList().OrderBy(e => e.Id).ToList(); @@ -1407,7 +1407,7 @@ public virtual void Select_DTO_constructor_distinct_translated_to_server() .Select(o => new OrderCountDTO(o.CustomerID)) .Distinct().ToList().OrderBy(e => e.Id).ToList(); - var expected = QueryAsserter.ExpectedData.Set() + var expected = Fixture.GetExpectedData(context, applyFilters: false).Set() .Where(o => o.OrderID < 10300) .Select(o => new OrderCountDTO(o.CustomerID)) .Distinct().ToList().OrderBy(e => e.Id).ToList(); @@ -1429,7 +1429,7 @@ public virtual void Select_DTO_constructor_distinct_with_navigation_translated_t .Select(o => new OrderCountDTO(o.Customer.City)) .Distinct().ToList().OrderBy(e => e.Id).ToList(); - var expected = QueryAsserter.ExpectedData.Set() + var expected = Fixture.GetExpectedData(context, applyFilters: false).Set() .Where(o => o.OrderID < 10300) .Select(o => new OrderCountDTO(o.Customer.City)) .Distinct().ToList().OrderBy(e => e.Id).ToList(); @@ -1452,7 +1452,7 @@ public virtual void Select_DTO_with_member_init_distinct_translated_to_server() o => new OrderCountDTO { Id = o.CustomerID, Count = o.OrderID }) .Distinct().ToList().OrderBy(e => e.Count).ToList(); - var expected = QueryAsserter.ExpectedData.Set() + var expected = Fixture.GetExpectedData(context, applyFilters: false).Set() .Where(o => o.OrderID < 10300) .Select( o => new OrderCountDTO { Id = o.CustomerID, Count = o.OrderID }) @@ -1476,7 +1476,7 @@ public virtual void Select_nested_collection_count_using_DTO() c => new OrderCountDTO { Id = c.CustomerID, Count = c.Orders.Count }) .ToList().OrderBy(e => e.Id).ToList(); - var expected = QueryAsserter.ExpectedData.Set() + var expected = Fixture.GetExpectedData(context, applyFilters: false).Set() .Where(c => c.CustomerID.StartsWith("A")) .Select( c => new OrderCountDTO { Id = c.CustomerID, Count = c.Orders.Count }) @@ -1532,8 +1532,8 @@ from o in context.Set().Where(o => o.OrderID < 10300) .Distinct() select new { c, o }).ToList().OrderBy(e => e.c.CustomerID + " " + e.o.Count).ToList(); - var expected = (from c in QueryAsserter.ExpectedData.Set().Where(c => c.CustomerID.StartsWith("A")) - from o in QueryAsserter.ExpectedData.Set().Where(o => o.OrderID < 10300) + var expected = (from c in Fixture.GetExpectedData(context, false).Set().Where(c => c.CustomerID.StartsWith("A")) + from o in Fixture.GetExpectedData(context, false).Set().Where(o => o.OrderID < 10300) .Select( o => new OrderCountDTO { Id = o.CustomerID, Count = o.OrderID }) .Distinct() diff --git a/test/EFCore.Specification.Tests/Query/NorthwindQueryFiltersQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/NorthwindQueryFiltersQueryTestBase.cs index 46fff720565..013940786a2 100644 --- a/test/EFCore.Specification.Tests/Query/NorthwindQueryFiltersQueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/NorthwindQueryFiltersQueryTestBase.cs @@ -6,6 +6,7 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.Diagnostics; using Microsoft.EntityFrameworkCore.TestModels.Northwind; +using Microsoft.EntityFrameworkCore.TestUtilities; using Xunit; // ReSharper disable StaticMemberInGenericType @@ -15,142 +16,209 @@ // ReSharper disable StringStartsWithIsCultureSpecific namespace Microsoft.EntityFrameworkCore.Query { - public abstract class NorthwindQueryFiltersQueryTestBase : IClassFixture, IDisposable + public abstract class NorthwindQueryFiltersQueryTestBase : FilteredQueryTestBase where TFixture : NorthwindQueryFixtureBase, new() { - private readonly NorthwindContext _context; - protected NorthwindQueryFiltersQueryTestBase(TFixture fixture) + : base(fixture) { - Fixture = fixture; - - _context = CreateContext(); } - protected TFixture Fixture { get; } - - [ConditionalFact] - public virtual void Count_query() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Count_query(bool async) { - Assert.Equal(7, _context.Customers.Count()); + return AssertFilteredCount( + async, + ss => ss.Set()); } - [ConditionalFact] - public virtual void Materialized_query() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Materialized_query(bool async) { - Assert.Equal(7, _context.Customers.ToList().Count); + return AssertFilteredQuery( + async, + ss => ss.Set(), + entryCount: 7); } - [ConditionalFact] - public virtual void Find() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Find(bool async) { - Assert.Null(_context.Find("ALFKI")); + using var context = Fixture.CreateContext(); + if (async) + { + Assert.Null(await context.FindAsync("ALFKI")); + } + else + { + Assert.Null(context.Find("ALFKI")); + } } - [ConditionalFact] - public virtual void Client_eval() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Client_eval(bool async) { Assert.Equal( CoreStrings.TranslationFailed("DbSet() .Where(p => NorthwindContext.ClientMethod(p))"), RemoveNewLines( - Assert.Throws( - () => _context.Products.ToList()).Message)); + (await Assert.ThrowsAsync( + () => AssertFilteredQuery( + async, + ss => ss.Set()))).Message)); } - [ConditionalFact] - public virtual async Task Materialized_query_async() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Materialized_query_parameter(bool async) { - Assert.Equal(7, (await _context.Customers.ToListAsync()).Count); + using var context = Fixture.CreateContext(); + context.TenantPrefix = "F"; + + if (async) + { + Assert.Equal(8, (await context.Customers.ToListAsync()).Count); + } + else + { + Assert.Equal(8, context.Customers.ToList().Count); + } } - [ConditionalFact] - public virtual void Materialized_query_parameter() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Materialized_query_parameter_new_context(bool async) { - _context.TenantPrefix = "F"; + using var context1 = Fixture.CreateContext(); + if (async) + { + Assert.Equal(7, (await context1.Customers.ToListAsync()).Count); - Assert.Equal(8, _context.Customers.ToList().Count); - } + using var context2 = Fixture.CreateContext(); + context2.TenantPrefix = "T"; - [ConditionalFact] - public virtual void Materialized_query_parameter_new_context() - { - Assert.Equal(7, _context.Customers.ToList().Count); + Assert.Equal(6, (await context2.Customers.ToListAsync()).Count); + } + else + { + Assert.Equal(7, context1.Customers.ToList().Count); - using var context = CreateContext(); - context.TenantPrefix = "T"; + using var context2 = Fixture.CreateContext(); + context2.TenantPrefix = "T"; - Assert.Equal(6, context.Customers.ToList().Count); + Assert.Equal(6, context2.Customers.ToList().Count); + } } - [ConditionalFact] - public virtual void Projection_query() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Projection_query(bool async) { - Assert.Equal(7, _context.Customers.Select(c => c.CustomerID).ToList().Count); + return AssertFilteredQuery( + async, + ss => ss.Set().Select(c => c.CustomerID)); } - [ConditionalFact] - public virtual void Projection_query_parameter() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Projection_query_parameter(bool async) { - _context.TenantPrefix = "F"; + using var context = Fixture.CreateContext(); + if (async) + { + context.TenantPrefix = "F"; + + Assert.Equal(8, (await context.Customers.Select(c => c.CustomerID).ToListAsync()).Count); + } + else + { + context.TenantPrefix = "F"; - Assert.Equal(8, _context.Customers.Select(c => c.CustomerID).ToList().Count); + Assert.Equal(8, context.Customers.Select(c => c.CustomerID).ToList().Count); + } } - [ConditionalFact] - public virtual void Include_query() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Include_query(bool async) { - var results = _context.Customers.Include(c => c.Orders).ToList(); - - Assert.Equal(7, results.Count); + return AssertFilteredQuery( + async, + ss => ss.Set().Include(c => c.Orders), + elementAsserter: (e, a) => AssertInclude(e, a, new ExpectedInclude(x => x.Orders)), + entryCount: 87); } - [ConditionalFact] - public virtual void Include_query_opt_out() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Include_query_opt_out(bool async) { - var results = _context.Customers.Include(c => c.Orders).IgnoreQueryFilters().ToList(); - - Assert.Equal(91, results.Count); + return AssertQuery( + async, + ss => ss.Set().Include(c => c.Orders).IgnoreQueryFilters(), + elementAsserter: (e, a) => AssertInclude(e, a, new ExpectedInclude(x => x.Orders)), + entryCount: 921); } - [ConditionalFact] - public virtual void Included_many_to_one_query() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Included_many_to_one_query2(bool async) { - var results = _context.Orders.Include(o => o.Customer).ToList(); - - Assert.Equal(80, results.Count); - Assert.True(results.All(o => o.Customer == null || o.CustomerID.StartsWith("B"))); + return AssertFilteredQuery( + async, + ss => ss.Set().Include(o => o.Customer), + entryCount: 87); } - [ConditionalFact] - public virtual void Project_reference_that_itself_has_query_filter_with_another_reference() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Included_many_to_one_query(bool async) { - var results = _context.OrderDetails.Select(od => od.Order).ToList(); + return AssertFilteredQuery( + async, + ss => ss.Set().Include(o => o.Customer), + elementAsserter: (e, a) => AssertInclude(e, a, new ExpectedInclude(x => x.Customer)), + entryCount: 87); + } - Assert.Equal(5, results.Count); - Assert.True(results.All(o => o.Customer == null || o.CustomerID.StartsWith("B"))); + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Project_reference_that_itself_has_query_filter_with_another_reference(bool async) + { + return AssertFilteredQuery( + async, + ss => ss.Set().Select(od => od.Order), + entryCount: 5); } - [ConditionalFact] - public virtual void Included_one_to_many_query_with_client_eval() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Included_one_to_many_query_with_client_eval(bool async) { Assert.Equal( CoreStrings.TranslationFailed("DbSet() .Where(p => NorthwindContext.ClientMethod(p))"), RemoveNewLines( - Assert.Throws( - () => _context.Products.Include(p => p.OrderDetails).ToList()).Message)); + (await Assert.ThrowsAsync( + () => AssertFilteredQuery( + async, + ss => ss.Set().Include(p => p.OrderDetails)))).Message)); } - [ConditionalFact] - public virtual void Navs_query() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Navs_query(bool async) { - var results - = (from c in _context.Customers - from o in c.Orders - from od in o.OrderDetails - where od.Discount < 10 - select c).ToList(); - - Assert.Equal(5, results.Count); + return AssertFilteredQuery( + async, + ss => from c in ss.Set() + from o in c.Orders + from od in o.OrderDetails + where od.Discount < 10 + select c, + entryCount: 3); } [ConditionalFact] @@ -160,26 +228,23 @@ public virtual void Compiled_query() (NorthwindContext context, string customerID) => context.Customers.Where(c => c.CustomerID == customerID)); - Assert.Equal("BERGS", query(_context, "BERGS").First().CustomerID); + using var context1 = Fixture.CreateContext(); + Assert.Equal("BERGS", query(context1, "BERGS").First().CustomerID); - using var context = CreateContext(); - Assert.Equal("BLAUS", query(context, "BLAUS").First().CustomerID); + using var context2 = Fixture.CreateContext(); + Assert.Equal("BLAUS", query(context2, "BLAUS").First().CustomerID); } - [ConditionalFact] - public virtual void Entity_Equality() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Entity_Equality(bool async) { - var results = _context.Orders.ToList(); - - Assert.Equal(80, results.Count); + return AssertFilteredQuery( + async, + ss => ss.Set(), + entryCount: 80); } - protected NorthwindContext CreateContext() - => Fixture.CreateContext(); - - public void Dispose() - => _context.Dispose(); - private string RemoveNewLines(string message) => message.Replace("\n", "").Replace("\r", ""); } diff --git a/test/EFCore.Specification.Tests/Query/NorthwindQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/NorthwindQueryFixtureBase.cs index 1eee282f740..fc26f04493c 100644 --- a/test/EFCore.Specification.Tests/Query/NorthwindQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/NorthwindQueryFixtureBase.cs @@ -18,8 +18,59 @@ public abstract class NorthwindQueryFixtureBase : SharedStoreF public Func GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new NorthwindData(); + private readonly Dictionary<(bool, string, string), ISetSource> _expectedDataCache = new Dictionary<(bool, string, string), ISetSource>(); + + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + var tenantPrefix = applyFilters ? ((NorthwindContext)context).TenantPrefix : null; + var searchTerm = applyFilters ? ((NorthwindContext)context).SearchTerm : null; + + if (_expectedDataCache.TryGetValue((applyFilters, tenantPrefix, searchTerm), out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new NorthwindData(); + if (applyFilters && typeof(TModelCustomizer) == typeof(NorthwindQueryFiltersCustomizer)) + { + var customers = expectedData.Customers.Where(c => c.CompanyName.StartsWith(tenantPrefix)).ToArray(); + var customerQueriesWithQueryFilter = expectedData.CustomerQueriesWithQueryFilter.Where(cq => cq.CompanyName.StartsWith(searchTerm)).ToArray(); + var employees = expectedData.Employees.Where(e => e.Address.StartsWith("A")).ToArray(); + var products = expectedData.Products.Where(p => p.Discontinued).ToArray(); + var orders = expectedData.Orders.Where(o => o.Customer.CompanyName.StartsWith(tenantPrefix)).ToArray(); + var orderDetails = expectedData.OrderDetails.Where(od => od.Order.Customer.CompanyName.StartsWith(tenantPrefix) && od.Quantity > 50).ToArray(); + + foreach (var product in products) + { + product.OrderDetails = product.OrderDetails.Where(od => od.Quantity > 50).ToList(); + } + + foreach (var order in orders) + { + order.OrderDetails = order.OrderDetails.Where(od => od.Quantity > 50).ToList(); + } + + foreach (var orderDetail in orderDetails) + { + orderDetail.Order = orderDetail.Order.Customer.CompanyName.StartsWith(tenantPrefix) ? orderDetail.Order : null; + orderDetail.Product = orderDetail.Product.Discontinued ? orderDetail.Product : null; + } + + expectedData = new NorthwindData( + customers, + expectedData.CustomerQueries, + customerQueriesWithQueryFilter, + employees, + products, + expectedData.ProductQueries, + orders, + orderDetails); + } + + _expectedDataCache[(applyFilters, tenantPrefix, searchTerm)] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/OwnedQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/OwnedQueryTestBase.cs index f6c445363f2..3412682256b 100644 --- a/test/EFCore.Specification.Tests/Query/OwnedQueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/OwnedQueryTestBase.cs @@ -400,7 +400,8 @@ public virtual async Task Owned_entity_without_owner_does_not_throw_for_identity public virtual async Task Preserve_includes_when_applying_skip_take_after_anonymous_type_select(bool async) { using var context = CreateContext(); - var expectedQuery = QueryAsserter.ExpectedData.Set().OrderBy(p => p.Id); + var expectedQuery = Fixture.GetExpectedData(context, applyFilters: false).Set().OrderBy(p => p.Id); + //var expectedQuery = QueryAsserter.ExpectedData.Set().OrderBy(p => p.Id); var expectedResult = expectedQuery.Select(q => new { Query = q, Count = expectedQuery.Count() }).Skip(0).Take(100).ToList(); var baseQuery = context.Set().OrderBy(p => p.Id); @@ -848,7 +849,7 @@ public virtual async Task Query_on_collection_entry_works_for_owned_collection(b ? await collectionQuery.ToListAsync() : collectionQuery.ToList(); - var expectedOrders = Fixture.GetExpectedData().Set().Single(e => e.Id == 1).Orders; + var expectedOrders = Fixture.GetExpectedData(context, applyFilters: false).Set().Single(e => e.Id == 1).Orders; Assert.Equal(expectedOrders.Count, actualOrders.Count); foreach (var element in expectedOrders.OrderBy(ee => ee.Id).Zip(actualOrders.OrderBy(aa => aa.Id), (e, a) => new { e, a })) @@ -908,8 +909,20 @@ private static void AssertOrders(ICollection expectedOrders, ICollection< public Func GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new OwnedQueryData(); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new OwnedQueryData(); + _expectedDataCache[applyFilters] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => new Dictionary> diff --git a/test/EFCore.Specification.Tests/Query/QueryTestBase.cs b/test/EFCore.Specification.Tests/Query/QueryTestBase.cs index 046c090eac4..4e5ae987510 100644 --- a/test/EFCore.Specification.Tests/Query/QueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/QueryTestBase.cs @@ -26,7 +26,11 @@ protected QueryTestBase(TFixture fixture) protected QueryAsserter QueryAsserter { get; } protected virtual QueryAsserter CreateQueryAsserter(TFixture fixture) - => new QueryAsserter(fixture, RewriteExpectedQueryExpression, RewriteServerQueryExpression, IgnoreEntryCount); + => new QueryAsserter( + fixture, + RewriteExpectedQueryExpression, + RewriteServerQueryExpression, + IgnoreEntryCount); protected virtual bool IgnoreEntryCount => false; diff --git a/test/EFCore.Specification.Tests/Query/SpatialQueryFixtureBase.cs b/test/EFCore.Specification.Tests/Query/SpatialQueryFixtureBase.cs index 9ea8fdc0fa6..4facb083538 100644 --- a/test/EFCore.Specification.Tests/Query/SpatialQueryFixtureBase.cs +++ b/test/EFCore.Specification.Tests/Query/SpatialQueryFixtureBase.cs @@ -18,8 +18,20 @@ public abstract class SpatialQueryFixtureBase : SharedStoreFixtureBase GetContextCreator() => () => CreateContext(); - public ISetSource GetExpectedData() - => new SpatialData(GeometryFactory); + private readonly Dictionary _expectedDataCache = new Dictionary(); + + public virtual ISetSource GetExpectedData(DbContext context, bool applyFilters) + { + if (_expectedDataCache.TryGetValue(applyFilters, out var cachedResult)) + { + return cachedResult; + } + + var expectedData = new SpatialData(GeometryFactory); + _expectedDataCache[applyFilters] = expectedData; + + return expectedData; + } public IReadOnlyDictionary GetEntitySorters() => null; diff --git a/test/EFCore.Specification.Tests/TestModels/InheritanceModel/InheritanceData.cs b/test/EFCore.Specification.Tests/TestModels/InheritanceModel/InheritanceData.cs index 72d538e6777..78d5355eaae 100644 --- a/test/EFCore.Specification.Tests/TestModels/InheritanceModel/InheritanceData.cs +++ b/test/EFCore.Specification.Tests/TestModels/InheritanceModel/InheritanceData.cs @@ -42,7 +42,21 @@ public InheritanceData() EagleId = ((Bird)a).EagleId, IsFlightless = ((Bird)a).IsFlightless, FoundOn = ((Kiwi)a).FoundOn, - }).ToList().AsReadOnly(); + }).ToList(); + } + + public InheritanceData( + IReadOnlyList animals, + IReadOnlyList animalQueries, + IReadOnlyList countries, + IReadOnlyList drinks, + IReadOnlyList plants) + { + Animals = animals; + AnimalQueries = animalQueries; + Countries = countries; + Drinks = drinks; + Plants = plants; } public virtual IQueryable Set() diff --git a/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindContext.cs b/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindContext.cs index 5f67e8e68ee..5bff4b970ac 100644 --- a/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindContext.cs +++ b/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindContext.cs @@ -92,7 +92,7 @@ public void ConfigureFilters(ModelBuilder modelBuilder) modelBuilder.Entity().HasQueryFilter(c => c.CompanyName.StartsWith(TenantPrefix)); modelBuilder.Entity().HasQueryFilter(o => o.Customer != null && o.Customer.CompanyName != null); - modelBuilder.Entity().HasQueryFilter(od => EF.Property(od, "Quantity") > _quantity); + modelBuilder.Entity().HasQueryFilter(od => od.Order != null && EF.Property(od, "Quantity") > _quantity); modelBuilder.Entity().HasQueryFilter(e => e.Address.StartsWith("A")); modelBuilder.Entity().HasQueryFilter(p => ClientMethod(p)); modelBuilder.Entity().HasQueryFilter(cq => cq.CompanyName.StartsWith(SearchTerm)); diff --git a/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindData.cs b/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindData.cs index d91e57146a8..63d8ab59566 100644 --- a/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindData.cs +++ b/test/EFCore.Specification.Tests/TestModels/Northwind/NorthwindData.cs @@ -12,27 +12,28 @@ namespace Microsoft.EntityFrameworkCore.TestModels.Northwind { public partial class NorthwindData : ISetSource { - private readonly Customer[] _customers; - private readonly CustomerQuery[] _customerQueries; - private readonly Employee[] _employees; - private readonly Product[] _products; - private readonly ProductQuery[] _productQueries; - private readonly Order[] _orders; - private readonly OrderQuery[] _orderQueries; - private readonly OrderDetail[] _orderDetails; + public Customer[] Customers { get; } + public CustomerQuery[] CustomerQueries { get; } + public CustomerQueryWithQueryFilter[] CustomerQueriesWithQueryFilter { get; } + public Employee[] Employees { get; } + public Product[] Products { get; } + public ProductQuery[] ProductQueries { get; } + public Order[] Orders { get; } + public OrderQuery[] OrderQueries { get; } + public OrderDetail[] OrderDetails { get; } public NorthwindData() { - _customers = CreateCustomers(); - _employees = CreateEmployees(); - _products = CreateProducts(); - _orders = CreateOrders(); - _orderDetails = CreateOrderDetails(); + Customers = CreateCustomers(); + Employees = CreateEmployees(); + Products = CreateProducts(); + Orders = CreateOrders(); + OrderDetails = CreateOrderDetails(); var customerQueries = new List(); - var customerQueriesWithQueryFilter = new List(); + CustomerQueriesWithQueryFilter = new CustomerQueryWithQueryFilter[0]; - foreach (var customer in _customers) + foreach (var customer in Customers) { customer.Orders = new List(); @@ -47,11 +48,11 @@ public NorthwindData() }); } - _customerQueries = customerQueries.ToArray(); + CustomerQueries = customerQueries.ToArray(); var productQueries = new List(); - foreach (var product in _products) + foreach (var product in Products) { product.OrderDetails = new List(); @@ -67,15 +68,15 @@ public NorthwindData() } } - _productQueries = productQueries.ToArray(); + ProductQueries = productQueries.ToArray(); var orderQueries = new List(); - foreach (var order in _orders) + foreach (var order in Orders) { order.OrderDetails = new List(); - var customer = _customers.First(c => c.CustomerID == order.CustomerID); + var customer = Customers.First(c => c.CustomerID == order.CustomerID); order.Customer = customer; customer.Orders.Add(order); @@ -83,67 +84,87 @@ public NorthwindData() new OrderQuery { CustomerID = order.CustomerID, Customer = order.Customer }); } - _orderQueries = orderQueries.ToArray(); + OrderQueries = orderQueries.ToArray(); - foreach (var orderDetail in _orderDetails) + foreach (var orderDetail in OrderDetails) { - var order = _orders.First(o => o.OrderID == orderDetail.OrderID); + var order = Orders.First(o => o.OrderID == orderDetail.OrderID); orderDetail.Order = order; order.OrderDetails.Add(orderDetail); - var product = _products.First(p => p.ProductID == orderDetail.ProductID); + var product = Products.First(p => p.ProductID == orderDetail.ProductID); orderDetail.Product = product; product.OrderDetails.Add(orderDetail); } - foreach (var employee in _employees) + foreach (var employee in Employees) { - var manager = _employees.FirstOrDefault(e => employee.ReportsTo == e.EmployeeID); + var manager = Employees.FirstOrDefault(e => employee.ReportsTo == e.EmployeeID); employee.Manager = manager; } } + public NorthwindData( + Customer[] customers, + CustomerQuery[] customerQueries, + CustomerQueryWithQueryFilter[] customerQueriesWithQueryFilter, + Employee[] employees, + Product[] products, + ProductQuery[] productQueries, + Order[] orders, + OrderDetail[] orderDetails) + { + Customers = customers; + CustomerQueries = customerQueries; + CustomerQueriesWithQueryFilter = customerQueriesWithQueryFilter; + Employees = employees; + Products = products; + ProductQueries = productQueries; + Orders = orders; + OrderDetails = orderDetails; + } + public IQueryable Set() where TEntity : class { if (typeof(TEntity) == typeof(Customer)) { - return (IQueryable)_customers.AsQueryable(); + return (IQueryable)Customers.AsQueryable(); } if (typeof(TEntity) == typeof(Employee)) { - return (IQueryable)_employees.AsQueryable(); + return (IQueryable)Employees.AsQueryable(); } if (typeof(TEntity) == typeof(Order)) { - return (IQueryable)_orders.AsQueryable(); + return (IQueryable)Orders.AsQueryable(); } if (typeof(TEntity) == typeof(OrderDetail)) { - return (IQueryable)_orderDetails.AsQueryable(); + return (IQueryable)OrderDetails.AsQueryable(); } if (typeof(TEntity) == typeof(Product)) { - return (IQueryable)_products.AsQueryable(); + return (IQueryable)Products.AsQueryable(); } if (typeof(TEntity) == typeof(CustomerQuery)) { - return (IQueryable)_customerQueries.AsQueryable(); + return (IQueryable)CustomerQueries.AsQueryable(); } if (typeof(TEntity) == typeof(OrderQuery)) { - return (IQueryable)_orderQueries.AsQueryable(); + return (IQueryable)OrderQueries.AsQueryable(); } if (typeof(TEntity) == typeof(ProductQuery)) { - return (IQueryable)_productQueries.AsQueryable(); + return (IQueryable)ProductQueries.AsQueryable(); } throw new InvalidOperationException("Invalid entity type: " + typeof(TEntity)); diff --git a/test/EFCore.Specification.Tests/TestUtilities/QueryAsserter.cs b/test/EFCore.Specification.Tests/TestUtilities/QueryAsserter.cs index 2ea7de6a9cd..e573d4e34a6 100644 --- a/test/EFCore.Specification.Tests/TestUtilities/QueryAsserter.cs +++ b/test/EFCore.Specification.Tests/TestUtilities/QueryAsserter.cs @@ -28,8 +28,10 @@ public class QueryAsserter private readonly Func _contextCreator; private readonly IReadOnlyDictionary _entitySorters; private readonly IReadOnlyDictionary _entityAsserters; + private readonly Func _rewriteExpectedQueryExpression; private readonly Func _rewriteServerQueryExpression; + private readonly bool _ignoreEntryCount; private const bool ProceduralQueryGeneration = false; private readonly List _includePath = new List(); @@ -40,8 +42,9 @@ public QueryAsserter( Func rewriteServerQueryExpression, bool ignoreEntryCount = false) { + QueryFixture = queryFixture; _contextCreator = queryFixture.GetContextCreator(); - ExpectedData = queryFixture.GetExpectedData(); + //ExpectedData = queryFixture.GetExpectedData(); _entitySorters = queryFixture.GetEntitySorters() ?? new Dictionary(); _entityAsserters = queryFixture.GetEntityAsserters() ?? new Dictionary(); SetSourceCreator = queryFixture.GetSetSourceCreator(); @@ -53,7 +56,9 @@ public QueryAsserter( public virtual Func SetSourceCreator { get; } - public virtual ISetSource ExpectedData { get; } + protected IQueryFixtureBase QueryFixture { get; } + + //public virtual ISetSource ExpectedData { get; } protected virtual void AssertRogueExecution(int expectedCount, IQueryable queryable) { @@ -65,7 +70,8 @@ public async Task AssertSingleResult( Expression> expectedQuery, Action asserter, int entryCount, - bool async) + bool async, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -73,7 +79,8 @@ public async Task AssertSingleResult( : actualSyncQuery.Compile()(SetSourceCreator(context)); var rewrittenExpectedQueryExpression = (Expression>)_rewriteExpectedQueryExpression(expectedQuery); - var expected = rewrittenExpectedQueryExpression.Compile()(ExpectedData); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = rewrittenExpectedQueryExpression.Compile()(expectedData); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -87,7 +94,8 @@ public async Task AssertQuery( bool assertOrder, int entryCount, bool async, - string testMethodName) + string testMethodName, + bool filteredQuery = false) { using var context = _contextCreator(); var query = RewriteServerQuery(actualQuery(SetSourceCreator(context))); @@ -106,7 +114,8 @@ public async Task AssertQuery( AssertRogueExecution(actual.Count, query); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).ToList(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).ToList(); if (!assertOrder && elementSorter == null) @@ -153,7 +162,8 @@ public async Task AssertQueryScalar( Func> expectedQuery, bool assertOrder, bool async, - string testMethodName) + string testMethodName, + bool filteredQuery = false) where TResult : struct { using var context = _contextCreator(); @@ -173,7 +183,8 @@ public async Task AssertQueryScalar( AssertRogueExecution(actual.Count, query); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).ToList(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).ToList(); TestHelpers.AssertResults( expected, @@ -188,7 +199,8 @@ public async Task AssertQueryScalar( Func> expectedQuery, bool assertOrder, bool async, - string testMethodName) + string testMethodName, + bool filteredQuery = false) where TResult : struct { using var context = _contextCreator(); @@ -208,7 +220,8 @@ public async Task AssertQueryScalar( AssertRogueExecution(actual.Count, query); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).ToList(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).ToList(); TestHelpers.AssertResults( expected, @@ -223,14 +236,16 @@ public async Task AssertQueryScalar( public async Task AssertAny( Func> actualQuery, Func> expectedQuery, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AnyAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Any(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Any(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Any(); Assert.Equal(expected, actual); } @@ -240,7 +255,8 @@ public async Task AssertAny( Func> expectedQuery, Expression> actualPredicate, Expression> expectedPredicate, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -248,7 +264,9 @@ public async Task AssertAny( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Any(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Any(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Any(rewrittenExpectedPredicate); Assert.Equal(expected, actual); } @@ -258,7 +276,8 @@ public async Task AssertAll( Func> expectedQuery, Expression> actualPredicate, Expression> expectedPredicate, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -266,7 +285,9 @@ public async Task AssertAll( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).All(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).All(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).All(rewrittenExpectedPredicate); Assert.Equal(expected, actual); } @@ -276,14 +297,16 @@ public async Task AssertFirst( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).FirstAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).First(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).First(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).First(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -296,7 +319,8 @@ public async Task AssertFirst( Expression> expectedPredicate, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -304,7 +328,9 @@ public async Task AssertFirst( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).First(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).First(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).First(rewrittenExpectedPredicate); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -315,14 +341,16 @@ public async Task AssertFirstOrDefault( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).FirstOrDefaultAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).FirstOrDefault(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).FirstOrDefault(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).FirstOrDefault(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -335,7 +363,8 @@ public async Task AssertFirstOrDefault( Expression> expectedPredicate, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -343,7 +372,9 @@ public async Task AssertFirstOrDefault( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).FirstOrDefault(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).FirstOrDefault(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).FirstOrDefault(rewrittenExpectedPredicate); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -354,14 +385,16 @@ public async Task AssertSingle( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SingleAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Single(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Single(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Single(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -374,7 +407,8 @@ public async Task AssertSingle( Expression> expectedPredicate, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -382,7 +416,9 @@ public async Task AssertSingle( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Single(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Single(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Single(rewrittenExpectedPredicate); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -393,14 +429,16 @@ public async Task AssertSingleOrDefault( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SingleOrDefaultAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).SingleOrDefault(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).SingleOrDefault(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).SingleOrDefault(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -413,7 +451,8 @@ public async Task AssertSingleOrDefault( Expression> expectedPredicate, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -421,7 +460,9 @@ public async Task AssertSingleOrDefault( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).SingleOrDefault(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).SingleOrDefault(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).SingleOrDefault(rewrittenExpectedPredicate); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -432,14 +473,16 @@ public async Task AssertLast( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).LastAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Last(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Last(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Last(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -452,7 +495,8 @@ public async Task AssertLast( Expression> expectedPredicate, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -460,7 +504,9 @@ public async Task AssertLast( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Last(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Last(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Last(rewrittenExpectedPredicate); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -471,14 +517,16 @@ public async Task AssertLastOrDefault( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).LastOrDefaultAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).LastOrDefault(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).LastOrDefault(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).LastOrDefault(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -491,7 +539,8 @@ public async Task AssertLastOrDefault( Expression> expectedPredicate, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -499,7 +548,9 @@ public async Task AssertLastOrDefault( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).LastOrDefault(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).LastOrDefault(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).LastOrDefault(rewrittenExpectedPredicate); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -508,14 +559,16 @@ public async Task AssertLastOrDefault( public async Task AssertCount( Func> actualQuery, Func> expectedQuery, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).CountAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Count(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Count(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Count(); Assert.Equal(expected, actual); Assert.Empty(context.ChangeTracker.Entries()); @@ -526,7 +579,8 @@ public async Task AssertCount( Func> expectedQuery, Expression> actualPredicate, Expression> expectedPredicate, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -534,7 +588,9 @@ public async Task AssertCount( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Count(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Count(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Count(rewrittenExpectedPredicate); Assert.Equal(expected, actual); Assert.Empty(context.ChangeTracker.Entries()); @@ -543,14 +599,16 @@ public async Task AssertCount( public async Task AssertLongCount( Func> actualQuery, Func> expectedQuery, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).LongCountAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).LongCount(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).LongCount(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).LongCount(); Assert.Equal(expected, actual); Assert.Empty(context.ChangeTracker.Entries()); @@ -561,7 +619,8 @@ public async Task AssertLongCount( Func> expectedQuery, Expression> actualPredicate, Expression> expectedPredicate, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -569,7 +628,9 @@ public async Task AssertLongCount( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).LongCount(actualPredicate); var rewrittenExpectedPredicate = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedPredicate); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).LongCount(rewrittenExpectedPredicate); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).LongCount(rewrittenExpectedPredicate); Assert.Equal(expected, actual); Assert.Empty(context.ChangeTracker.Entries()); @@ -580,14 +641,16 @@ public async Task AssertMin( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).MinAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Min(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Min(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Min(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -600,7 +663,8 @@ public async Task AssertMin( Expression> expectedSelector, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -609,7 +673,9 @@ public async Task AssertMin( var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Min(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Min(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -620,14 +686,16 @@ public async Task AssertMax( Func> expectedQuery, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).MaxAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Max(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Max(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Max(); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -640,7 +708,8 @@ public async Task AssertMax( Expression> expectedSelector, Action asserter = null, int entryCount = 0, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -649,7 +718,9 @@ public async Task AssertMax( var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Max(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Max(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); AssertEntryCount(context, entryCount); @@ -659,14 +730,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -676,14 +749,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -693,14 +768,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -710,14 +787,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -727,14 +806,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -744,14 +825,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -761,14 +844,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -778,14 +863,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -795,14 +882,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -812,14 +901,16 @@ public async Task AssertSum( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).SumAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -831,7 +922,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -839,7 +931,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -851,7 +945,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -859,7 +954,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -871,7 +968,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -879,7 +977,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -891,7 +991,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -899,7 +1000,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -911,7 +1014,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -919,7 +1023,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -931,7 +1037,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -940,7 +1047,9 @@ public async Task AssertSum( var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -952,7 +1061,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -960,7 +1070,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -972,7 +1084,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -980,7 +1093,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -992,7 +1107,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1000,7 +1116,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1012,7 +1130,8 @@ public async Task AssertSum( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1020,7 +1139,9 @@ public async Task AssertSum( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Sum(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Sum(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Sum(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1030,14 +1151,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1047,14 +1170,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1064,14 +1189,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1081,14 +1208,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1098,14 +1227,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1115,14 +1246,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1132,14 +1265,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1149,14 +1284,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1166,14 +1303,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1183,14 +1322,16 @@ public async Task AssertAverage( Func> actualQuery, Func> expectedQuery, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async ? await RewriteServerQuery(actualQuery(SetSourceCreator(context))).AverageAsync() : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(); + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1202,7 +1343,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1210,7 +1352,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1222,7 +1366,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1230,7 +1375,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1242,7 +1389,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1250,7 +1398,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1262,7 +1412,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1270,7 +1421,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1282,7 +1435,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1290,7 +1444,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1302,7 +1458,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1311,7 +1468,9 @@ public async Task AssertAverage( var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1323,7 +1482,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1331,7 +1491,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1343,7 +1505,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1351,7 +1514,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1363,7 +1528,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1371,7 +1537,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); @@ -1383,7 +1551,8 @@ public async Task AssertAverage( Expression> actualSelector, Expression> expectedSelector, Action asserter = null, - bool async = false) + bool async = false, + bool filteredQuery = false) { using var context = _contextCreator(); var actual = async @@ -1391,7 +1560,9 @@ public async Task AssertAverage( : RewriteServerQuery(actualQuery(SetSourceCreator(context))).Average(actualSelector); var rewrittenExpectedSelector = (Expression>)new ExpectedQueryRewritingVisitor().Visit(expectedSelector); - var expected = RewriteExpectedQuery(expectedQuery(ExpectedData)).Average(rewrittenExpectedSelector); + + var expectedData = QueryFixture.GetExpectedData(context, filteredQuery); + var expected = RewriteExpectedQuery(expectedQuery(expectedData)).Average(rewrittenExpectedSelector); AssertEqual(expected, actual, asserter); Assert.Empty(context.ChangeTracker.Entries()); diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/AsyncGearsOfWarQuerySqlServerTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/AsyncGearsOfWarQuerySqlServerTest.cs deleted file mode 100644 index b0a21b1f4e6..00000000000 --- a/test/EFCore.SqlServer.FunctionalTests/Query/AsyncGearsOfWarQuerySqlServerTest.cs +++ /dev/null @@ -1,20 +0,0 @@ -// 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 Xunit.Abstractions; - -namespace Microsoft.EntityFrameworkCore.Query -{ - public class AsyncGearsOfWarQuerySqlServerTest : AsyncGearsOfWarQueryRelationalTestBase - { - public AsyncGearsOfWarQuerySqlServerTest(GearsOfWarQuerySqlServerFixture fixture, ITestOutputHelper testOutputHelper) - : base(fixture) - { - Fixture.TestSqlLoggerFactory.Clear(); - //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); - } - - protected override bool CanExecuteQueryString - => true; - } -} diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/ComplexNavigationsQuerySqlServerTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/ComplexNavigationsQuerySqlServerTest.cs index a6ed90946f1..f8055af551b 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/ComplexNavigationsQuerySqlServerTest.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/ComplexNavigationsQuerySqlServerTest.cs @@ -4985,9 +4985,9 @@ FROM [LevelOne] AS [l1] ORDER BY [l].[Id], [t0].[OneToMany_Optional_Inverse2Id], [t0].[Id]"); } - public override void Filtered_include_outer_parameter_used_inside_filter() + public override async Task Filtered_include_outer_parameter_used_inside_filter(bool async) { - base.Filtered_include_outer_parameter_used_inside_filter(); + await base.Filtered_include_outer_parameter_used_inside_filter(async); AssertSql( @"SELECT [l].[Id], [t].[Id], [t].[Date], [t].[Level1_Optional_Id], [t].[Level1_Required_Id], [t].[Name], [t].[OneToMany_Optional_Inverse2Id], [t].[OneToMany_Optional_Self_Inverse2Id], [t].[OneToMany_Required_Inverse2Id], [t].[OneToMany_Required_Self_Inverse2Id], [t].[OneToOne_Optional_PK_Inverse2Id], [t].[OneToOne_Optional_Self2Id], [t].[Id0], [t].[Level2_Optional_Id], [t].[Level2_Required_Id], [t].[Name0], [t].[OneToMany_Optional_Inverse3Id], [t].[OneToMany_Optional_Self_Inverse3Id], [t].[OneToMany_Required_Inverse3Id], [t].[OneToMany_Required_Self_Inverse3Id], [t].[OneToOne_Optional_PK_Inverse3Id], [t].[OneToOne_Optional_Self3Id], [t1].[Id], [t1].[Date], [t1].[Level1_Optional_Id], [t1].[Level1_Required_Id], [t1].[Name], [t1].[OneToMany_Optional_Inverse2Id], [t1].[OneToMany_Optional_Self_Inverse2Id], [t1].[OneToMany_Required_Inverse2Id], [t1].[OneToMany_Required_Self_Inverse2Id], [t1].[OneToOne_Optional_PK_Inverse2Id], [t1].[OneToOne_Optional_Self2Id], [t1].[Id0], [t1].[Level2_Optional_Id], [t1].[Level2_Required_Id], [t1].[Name0], [t1].[OneToMany_Optional_Inverse3Id], [t1].[OneToMany_Optional_Self_Inverse3Id], [t1].[OneToMany_Required_Inverse3Id], [t1].[OneToMany_Required_Self_Inverse3Id], [t1].[OneToOne_Optional_PK_Inverse3Id], [t1].[OneToOne_Optional_Self3Id] diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/FiltersInheritanceQuerySqlServerTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/FiltersInheritanceQuerySqlServerTest.cs index d911fe4d3aa..13615c0e46b 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/FiltersInheritanceQuerySqlServerTest.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/FiltersInheritanceQuerySqlServerTest.cs @@ -1,6 +1,7 @@ // 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.Threading.Tasks; using Xunit.Abstractions; namespace Microsoft.EntityFrameworkCore.Query @@ -14,9 +15,9 @@ public FiltersInheritanceQuerySqlServerTest(FiltersInheritanceQuerySqlServerFixt //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override void Can_use_of_type_animal() + public override async Task Can_use_of_type_animal(bool async) { - base.Can_use_of_type_animal(); + await base.Can_use_of_type_animal(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[Group], [a].[FoundOn] @@ -25,9 +26,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_is_kiwi() + public override async Task Can_use_is_kiwi(bool async) { - base.Can_use_is_kiwi(); + await base.Can_use_is_kiwi(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[Group], [a].[FoundOn] @@ -35,9 +36,9 @@ FROM [Animals] AS [a] WHERE ([a].[CountryId] = 1) AND ([a].[Discriminator] = N'Kiwi')"); } - public override void Can_use_is_kiwi_with_other_predicate() + public override async Task Can_use_is_kiwi_with_other_predicate(bool async) { - base.Can_use_is_kiwi_with_other_predicate(); + await base.Can_use_is_kiwi_with_other_predicate(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[Group], [a].[FoundOn] @@ -45,9 +46,9 @@ FROM [Animals] AS [a] WHERE ([a].[CountryId] = 1) AND (([a].[Discriminator] = N'Kiwi') AND ([a].[CountryId] = 1))"); } - public override void Can_use_is_kiwi_in_projection() + public override async Task Can_use_is_kiwi_in_projection(bool async) { - base.Can_use_is_kiwi_in_projection(); + await base.Can_use_is_kiwi_in_projection(async); AssertSql( @"SELECT CASE @@ -58,9 +59,9 @@ FROM [Animals] AS [a] WHERE [a].[CountryId] = 1"); } - public override void Can_use_of_type_bird() + public override async Task Can_use_of_type_bird(bool async) { - base.Can_use_of_type_bird(); + await base.Can_use_of_type_bird(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[Group], [a].[FoundOn] @@ -69,9 +70,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_of_type_bird_predicate() + public override async Task Can_use_of_type_bird_predicate(bool async) { - base.Can_use_of_type_bird_predicate(); + await base.Can_use_of_type_bird_predicate(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[Group], [a].[FoundOn] @@ -80,9 +81,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_of_type_bird_with_projection() + public override async Task Can_use_of_type_bird_with_projection(bool async) { - base.Can_use_of_type_bird_with_projection(); + await base.Can_use_of_type_bird_with_projection(async); AssertSql( @"SELECT [a].[EagleId] @@ -90,9 +91,9 @@ FROM [Animals] AS [a] WHERE [a].[CountryId] = 1"); } - public override void Can_use_of_type_bird_first() + public override async Task Can_use_of_type_bird_first(bool async) { - base.Can_use_of_type_bird_first(); + await base.Can_use_of_type_bird_first(async); AssertSql( @"SELECT TOP(1) [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[Group], [a].[FoundOn] @@ -101,9 +102,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_of_type_kiwi() + public override async Task Can_use_of_type_kiwi(bool async) { - base.Can_use_of_type_kiwi(); + await base.Can_use_of_type_kiwi(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[FoundOn] @@ -111,6 +112,16 @@ FROM [Animals] AS [a] WHERE ([a].[CountryId] = 1) AND ([a].[Discriminator] = N'Kiwi')"); } + public override async Task Can_use_derived_set(bool async) + { + await base.Can_use_derived_set(async); + + AssertSql( + @"SELECT [a].[Species], [a].[CountryId], [a].[Discriminator], [a].[Name], [a].[EagleId], [a].[IsFlightless], [a].[Group] +FROM [Animals] AS [a] +WHERE ([a].[Discriminator] = N'Eagle') AND ([a].[CountryId] = 1)"); + } + private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); } diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindQueryFiltersQuerySqlServerTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindQueryFiltersQuerySqlServerTest.cs index bec7c6de924..4ef19169626 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindQueryFiltersQuerySqlServerTest.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindQueryFiltersQuerySqlServerTest.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.Linq; +using System.Threading.Tasks; using Xunit; using Xunit.Abstractions; @@ -20,9 +21,9 @@ public NorthwindQueryFiltersQuerySqlServerTest( //fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override void Count_query() + public override async Task Count_query(bool async) { - base.Count_query(); + await base.Count_query(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -32,9 +33,9 @@ FROM [Customers] AS [c] WHERE (@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))"); } - public override void Materialized_query() + public override async Task Materialized_query(bool async) { - base.Materialized_query(); + await base.Materialized_query(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -44,9 +45,9 @@ FROM [Customers] AS [c] WHERE (@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))"); } - public override void Find() + public override async Task Find(bool async) { - base.Find(); + await base.Find(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -57,9 +58,9 @@ FROM [Customers] AS [c] WHERE ((@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))) AND ([c].[CustomerID] = @__p_0)"); } - public override void Materialized_query_parameter() + public override async Task Materialized_query_parameter(bool async) { - base.Materialized_query_parameter(); + await base.Materialized_query_parameter(async); AssertSql( @"@__ef_filter__TenantPrefix_0='F' (Size = 4000) @@ -69,9 +70,9 @@ FROM [Customers] AS [c] WHERE (@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))"); } - public override void Materialized_query_parameter_new_context() + public override async Task Materialized_query_parameter_new_context(bool async) { - base.Materialized_query_parameter_new_context(); + await base.Materialized_query_parameter_new_context(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -87,9 +88,9 @@ FROM [Customers] AS [c] WHERE (@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))"); } - public override void Projection_query_parameter() + public override async Task Projection_query_parameter(bool async) { - base.Projection_query_parameter(); + await base.Projection_query_parameter(async); AssertSql( @"@__ef_filter__TenantPrefix_0='F' (Size = 4000) @@ -99,9 +100,9 @@ FROM [Customers] AS [c] WHERE (@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))"); } - public override void Projection_query() + public override async Task Projection_query(bool async) { - base.Projection_query(); + await base.Projection_query(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -111,9 +112,9 @@ FROM [Customers] AS [c] WHERE (@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))"); } - public override void Include_query() + public override async Task Include_query(bool async) { - base.Include_query(); + await base.Include_query(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -134,9 +135,9 @@ WHERE [t].[CustomerID] IS NOT NULL AND [t].[CompanyName] IS NOT NULL ORDER BY [c].[CustomerID], [t0].[OrderID], [t0].[CustomerID0]"); } - public override void Include_query_opt_out() + public override async Task Include_query_opt_out(bool async) { - base.Include_query_opt_out(); + await base.Include_query_opt_out(async); AssertSql( @"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate] @@ -145,9 +146,9 @@ FROM [Customers] AS [c] ORDER BY [c].[CustomerID], [o].[OrderID]"); } - public override void Included_many_to_one_query() + public override async Task Included_many_to_one_query(bool async) { - base.Included_many_to_one_query(); + await base.Included_many_to_one_query(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -162,9 +163,9 @@ FROM [Customers] AS [c] WHERE [t].[CustomerID] IS NOT NULL AND [t].[CompanyName] IS NOT NULL"); } - public override void Project_reference_that_itself_has_query_filter_with_another_reference() + public override async Task Project_reference_that_itself_has_query_filter_with_another_reference(bool async) { - base.Project_reference_that_itself_has_query_filter_with_another_reference(); + await base.Project_reference_that_itself_has_query_filter_with_another_reference(async); AssertSql( @"@__ef_filter__TenantPrefix_1='B' (Size = 4000) @@ -185,9 +186,9 @@ WHERE [t].[CustomerID] IS NOT NULL AND [t].[CompanyName] IS NOT NULL WHERE [o].[Quantity] > @__ef_filter___quantity_0"); } - public override void Navs_query() + public override async Task Navs_query(bool async) { - base.Navs_query(); + await base.Navs_query(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) @@ -208,15 +209,25 @@ WHERE [t].[CustomerID] IS NOT NULL AND [t].[CompanyName] IS NOT NULL INNER JOIN ( SELECT [o0].[OrderID], [o0].[Discount] FROM [Order Details] AS [o0] + INNER JOIN ( + SELECT [o1].[OrderID] + FROM [Orders] AS [o1] + LEFT JOIN ( + SELECT [c1].[CustomerID], [c1].[CompanyName] + FROM [Customers] AS [c1] + WHERE (@__ef_filter__TenantPrefix_0 = N'') OR ([c1].[CompanyName] IS NOT NULL AND (LEFT([c1].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0)) + ) AS [t1] ON [o1].[CustomerID] = [t1].[CustomerID] + WHERE [t1].[CustomerID] IS NOT NULL AND [t1].[CompanyName] IS NOT NULL + ) AS [t2] ON [o0].[OrderID] = [t2].[OrderID] WHERE [o0].[Quantity] > @__ef_filter___quantity_1 -) AS [t1] ON [t0].[OrderID] = [t1].[OrderID] -WHERE ((@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))) AND ([t1].[Discount] < CAST(10 AS real))"); +) AS [t3] ON [t0].[OrderID] = [t3].[OrderID] +WHERE ((@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))) AND ([t3].[Discount] < CAST(10 AS real))"); } [ConditionalFact] public void FromSql_is_composed() { - using (var context = CreateContext()) + using (var context = Fixture.CreateContext()) { var results = context.Customers.FromSqlRaw("select * from Customers").ToList(); @@ -236,7 +247,7 @@ public void FromSql_is_composed() [ConditionalFact] public void FromSql_is_composed_when_filter_has_navigation() { - using (var context = CreateContext()) + using (var context = Fixture.CreateContext()) { var results = context.Orders.FromSqlRaw("select * from Orders").ToList(); @@ -278,9 +289,9 @@ FROM [Customers] AS [c] WHERE ((@__ef_filter__TenantPrefix_0 = N'') OR ([c].[CompanyName] IS NOT NULL AND (LEFT([c].[CompanyName], LEN(@__ef_filter__TenantPrefix_0)) = @__ef_filter__TenantPrefix_0))) AND ([c].[CustomerID] = @__customerID)"); } - public override void Entity_Equality() + public override async Task Entity_Equality(bool async) { - base.Entity_Equality(); + await base.Entity_Equality(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 4000) diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/TPTFiltersInheritanceQuerySqlServerTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/TPTFiltersInheritanceQuerySqlServerTest.cs index a90bb6481fd..9ca15dea63c 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/TPTFiltersInheritanceQuerySqlServerTest.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/TPTFiltersInheritanceQuerySqlServerTest.cs @@ -1,6 +1,7 @@ // 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.Threading.Tasks; using Xunit.Abstractions; namespace Microsoft.EntityFrameworkCore.Query @@ -16,9 +17,9 @@ public TPTFiltersInheritanceQuerySqlServerTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override void Can_use_of_type_animal() + public override async Task Can_use_of_type_animal(bool async) { - base.Can_use_of_type_animal(); + await base.Can_use_of_type_animal(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [e].[Group], [k].[FoundOn], CASE @@ -33,9 +34,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_is_kiwi() + public override async Task Can_use_is_kiwi(bool async) { - base.Can_use_is_kiwi(); + await base.Can_use_is_kiwi(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [e].[Group], [k].[FoundOn], CASE @@ -49,9 +50,9 @@ FROM [Animals] AS [a] WHERE ([a].[CountryId] = 1) AND [k].[Species] IS NOT NULL"); } - public override void Can_use_is_kiwi_with_other_predicate() + public override async Task Can_use_is_kiwi_with_other_predicate(bool async) { - base.Can_use_is_kiwi_with_other_predicate(); + await base.Can_use_is_kiwi_with_other_predicate(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [e].[Group], [k].[FoundOn], CASE @@ -65,9 +66,9 @@ FROM [Animals] AS [a] WHERE ([a].[CountryId] = 1) AND ([k].[Species] IS NOT NULL AND ([a].[CountryId] = 1))"); } - public override void Can_use_is_kiwi_in_projection() + public override async Task Can_use_is_kiwi_in_projection(bool async) { - base.Can_use_is_kiwi_in_projection(); + await base.Can_use_is_kiwi_in_projection(async); AssertSql( @"SELECT CASE @@ -79,9 +80,9 @@ FROM [Animals] AS [a] WHERE [a].[CountryId] = 1"); } - public override void Can_use_of_type_bird() + public override async Task Can_use_of_type_bird(bool async) { - base.Can_use_of_type_bird(); + await base.Can_use_of_type_bird(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [e].[Group], [k].[FoundOn], CASE @@ -96,9 +97,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_of_type_bird_predicate() + public override async Task Can_use_of_type_bird_predicate(bool async) { - base.Can_use_of_type_bird_predicate(); + await base.Can_use_of_type_bird_predicate(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [e].[Group], [k].[FoundOn], CASE @@ -113,9 +114,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_of_type_bird_with_projection() + public override async Task Can_use_of_type_bird_with_projection(bool async) { - base.Can_use_of_type_bird_with_projection(); + await base.Can_use_of_type_bird_with_projection(async); AssertSql( @"SELECT [b].[EagleId] @@ -126,9 +127,9 @@ FROM [Animals] AS [a] WHERE ([a].[CountryId] = 1) AND ([k].[Species] IS NOT NULL OR [e].[Species] IS NOT NULL)"); } - public override void Can_use_of_type_bird_first() + public override async Task Can_use_of_type_bird_first(bool async) { - base.Can_use_of_type_bird_first(); + await base.Can_use_of_type_bird_first(async); AssertSql( @"SELECT TOP(1) [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [e].[Group], [k].[FoundOn], CASE @@ -143,9 +144,9 @@ FROM [Animals] AS [a] ORDER BY [a].[Species]"); } - public override void Can_use_of_type_kiwi() + public override async Task Can_use_of_type_kiwi(bool async) { - base.Can_use_of_type_kiwi(); + await base.Can_use_of_type_kiwi(async); AssertSql( @"SELECT [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [k].[FoundOn], CASE @@ -157,6 +158,18 @@ FROM [Animals] AS [a] WHERE ([a].[CountryId] = 1) AND [k].[Species] IS NOT NULL"); } + public override async Task Can_use_derived_set(bool async) + { + await base.Can_use_derived_set(async); + + AssertSql( + @"SELECT [a].[Species], [a].[CountryId], [a].[Name], [b].[EagleId], [b].[IsFlightless], [e].[Group] +FROM [Animals] AS [a] +INNER JOIN [Birds] AS [b] ON [a].[Species] = [b].[Species] +INNER JOIN [Eagle] AS [e] ON [a].[Species] = [e].[Species] +WHERE [a].[CountryId] = 1"); + } + private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); } diff --git a/test/EFCore.Sqlite.FunctionalTests/Query/AsyncGearsOfWarQuerySqliteTest.cs b/test/EFCore.Sqlite.FunctionalTests/Query/AsyncGearsOfWarQuerySqliteTest.cs deleted file mode 100644 index 1779b17011e..00000000000 --- a/test/EFCore.Sqlite.FunctionalTests/Query/AsyncGearsOfWarQuerySqliteTest.cs +++ /dev/null @@ -1,17 +0,0 @@ -// 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 Xunit.Abstractions; - -namespace Microsoft.EntityFrameworkCore.Query -{ - public class AsyncGearsOfWarQuerySqliteTest : AsyncGearsOfWarQueryRelationalTestBase - { - public AsyncGearsOfWarQuerySqliteTest(GearsOfWarQuerySqliteFixture fixture, ITestOutputHelper testOutputHelper) - : base(fixture) - { - Fixture.TestSqlLoggerFactory.Clear(); - //TestSqlLoggerFactory.CaptureOutput(testOutputHelper); - } - } -} diff --git a/test/EFCore.Sqlite.FunctionalTests/Query/ComplexNavigationsQuerySqliteTest.cs b/test/EFCore.Sqlite.FunctionalTests/Query/ComplexNavigationsQuerySqliteTest.cs index 8b51d254ab5..c9957e49b4b 100644 --- a/test/EFCore.Sqlite.FunctionalTests/Query/ComplexNavigationsQuerySqliteTest.cs +++ b/test/EFCore.Sqlite.FunctionalTests/Query/ComplexNavigationsQuerySqliteTest.cs @@ -27,11 +27,11 @@ public override async Task Filtered_include_after_different_filtered_include_dif (await Assert.ThrowsAsync( () => base.Filtered_include_after_different_filtered_include_different_level(async))).Message); - public override void Filtered_include_outer_parameter_used_inside_filter() + public override async Task Filtered_include_outer_parameter_used_inside_filter(bool async) => Assert.Equal( SqliteStrings.ApplyNotSupported, - Assert.Throws( - () => base.Filtered_include_outer_parameter_used_inside_filter()).Message); + (await Assert.ThrowsAsync( + () => base.Filtered_include_outer_parameter_used_inside_filter(async))).Message); public override async Task Filtered_include_and_non_filtered_include_followed_by_then_include_on_same_navigation(bool async) => Assert.Equal( diff --git a/test/EFCore.Sqlite.FunctionalTests/Query/NorthwindQueryFiltersQuerySqliteTest.cs b/test/EFCore.Sqlite.FunctionalTests/Query/NorthwindQueryFiltersQuerySqliteTest.cs index 0cdf29b42be..e9c2142ae01 100644 --- a/test/EFCore.Sqlite.FunctionalTests/Query/NorthwindQueryFiltersQuerySqliteTest.cs +++ b/test/EFCore.Sqlite.FunctionalTests/Query/NorthwindQueryFiltersQuerySqliteTest.cs @@ -1,6 +1,7 @@ // 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.Threading.Tasks; using Xunit.Abstractions; namespace Microsoft.EntityFrameworkCore.Query @@ -17,9 +18,9 @@ public NorthwindQueryFiltersQuerySqliteTest( //fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override void Count_query() + public override async Task Count_query(bool async) { - base.Count_query(); + await base.Count_query(async); AssertSql( @"@__ef_filter__TenantPrefix_0='B' (Size = 1)