1583 lines
88 KiB
C#
1583 lines
88 KiB
C#
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
|
|
|
namespace System.Data.Entity
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.Data.Entity.Core.Objects;
|
|
using System.Data.Entity.Infrastructure;
|
|
using System.Data.Entity.Internal.Linq;
|
|
using System.Data.Entity.Resources;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Moq;
|
|
using Xunit;
|
|
|
|
public class IQueryableExtensionsTests
|
|
{
|
|
#region Entity types for Include tests
|
|
|
|
public class RootEntity
|
|
{
|
|
public Level1Entity Level1Reference { get; set; }
|
|
public ICollection<Level1Entity> Level1Collection { get; set; }
|
|
public ICollection<RootEntity> RootCollection { get; set; }
|
|
public RootEntity RootReference { get; set; }
|
|
}
|
|
|
|
public class Level1Entity
|
|
{
|
|
public bool BoolProperty { get; set; }
|
|
public Level2Entity Level2Reference { get; set; }
|
|
public ICollection<Level2Entity> Level2Collection { get; set; }
|
|
public ICollection<RootEntity> RootCollection { get; set; }
|
|
public RootEntity RootReference { get; set; }
|
|
}
|
|
|
|
public class Level2Entity
|
|
{
|
|
public Level3Entity Level3Reference { get; set; }
|
|
public ICollection<Level3Entity> Level3Collection { get; set; }
|
|
public ICollection<Level1Entity> Level1Collection { get; set; }
|
|
public Level1Entity Level1Reference { get; set; }
|
|
}
|
|
|
|
public class Level3Entity
|
|
{
|
|
public ICollection<Level2Entity> Level2Collection { get; set; }
|
|
public Level2Entity Level2Reference { get; set; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
public class AsNotracking_Generic
|
|
{
|
|
[Fact]
|
|
public void With_null_source_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
"source", Assert.Throws<ArgumentNullException>(() => IQueryableExtensions.AsNoTracking<FakeEntity>(null)).ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_ObjectQuery_returns_a_NoTracking_one()
|
|
{
|
|
var query = MockHelper.CreateMockObjectQuery(new object()).Object;
|
|
|
|
var newQuery = query.AsNoTracking();
|
|
|
|
Assert.NotSame(query, newQuery);
|
|
Assert.NotEqual(MergeOption.NoTracking, query.MergeOption);
|
|
Assert.Equal(MergeOption.NoTracking, ((ObjectQuery<object>)newQuery).MergeOption);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IEnumerable_does_nothing()
|
|
{
|
|
var enumerable = new List<FakeEntity>
|
|
{
|
|
new FakeEntity(),
|
|
new FakeEntity(),
|
|
new FakeEntity()
|
|
}.AsQueryable();
|
|
var afterNoTracking = enumerable.AsNoTracking();
|
|
|
|
Assert.Same(enumerable, afterNoTracking);
|
|
Assert.Equal(3, afterNoTracking.Count());
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_no_AsNoTracking_method_does_nothing()
|
|
{
|
|
var mockQueryable = new Mock<IQueryable<FakeEntity>>().Object;
|
|
var afterAsNoTracking = mockQueryable.AsNoTracking();
|
|
|
|
Assert.Same(mockQueryable, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingable<T> : IQueryable<T>
|
|
{
|
|
INoTrackingable<T> AsNoTracking();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsNoTracking_method_calls_that_method()
|
|
{
|
|
var mockQueryable = new Mock<INoTrackingable<FakeEntity>>(MockBehavior.Strict);
|
|
IQueryable<FakeEntity> source = mockQueryable.Object;
|
|
var result = new Mock<INoTrackingable<FakeEntity>>().Object;
|
|
mockQueryable.Setup(i => i.AsNoTracking()).Returns(result);
|
|
|
|
var afterAsNoTracking = source.AsNoTracking();
|
|
|
|
Assert.Same(result, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingableWithFunnyAsNoTracking<T> : IQueryable<T>
|
|
{
|
|
INoTrackingableWithFunnyAsNoTracking<T> AsNoTracking(string buffy, string summers);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_non_matching_AsNoTracking_is_ignored()
|
|
{
|
|
IQueryable<FakeEntity> source = new Mock<INoTrackingableWithFunnyAsNoTracking<FakeEntity>>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsNoTracking = source.AsNoTracking();
|
|
|
|
Assert.Same(source, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingableReturningVoid<T> : IQueryable<T>
|
|
{
|
|
void AsNoTracking();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_void_AsNoTracking_method_is_ignored()
|
|
{
|
|
var mockQueryable = new Mock<INoTrackingableReturningVoid<FakeEntity>>(MockBehavior.Strict);
|
|
|
|
var afterAsNoTracking = ((IQueryable<FakeEntity>)mockQueryable.Object).AsNoTracking();
|
|
|
|
Assert.Same(mockQueryable.Object, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingableReturningString<T> : IQueryable<T>
|
|
{
|
|
string AsNoTracking();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsNoTracking_returning_string_is_ignored()
|
|
{
|
|
IQueryable<FakeEntity> source = new Mock<INoTrackingableReturningString<FakeEntity>>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsNoTracking = source.AsNoTracking();
|
|
|
|
Assert.Same(source, afterAsNoTracking);
|
|
}
|
|
}
|
|
|
|
public class AsNotracking_NonGeneric
|
|
{
|
|
[Fact]
|
|
public void With_null_source_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal("source", Assert.Throws<ArgumentNullException>(() => IQueryableExtensions.AsNoTracking(null)).ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_ObjectQuery_returns_a_NoTracking_one()
|
|
{
|
|
var query = (ObjectQuery)MockHelper.CreateMockObjectQuery(new object()).Object;
|
|
|
|
var newQuery = query.AsNoTracking();
|
|
|
|
Assert.NotSame(query, newQuery);
|
|
Assert.NotEqual(MergeOption.NoTracking, query.MergeOption);
|
|
Assert.Equal(MergeOption.NoTracking, ((ObjectQuery)newQuery).MergeOption);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IEnumerable_does_nothing()
|
|
{
|
|
var enumerable = (IQueryable)new List<FakeEntity>
|
|
{
|
|
new FakeEntity(),
|
|
new FakeEntity(),
|
|
new FakeEntity()
|
|
}.AsQueryable();
|
|
var afterAsNoTracking = enumerable.AsNoTracking();
|
|
|
|
Assert.Same(enumerable, afterAsNoTracking);
|
|
Assert.Equal(3, afterAsNoTracking.ToList<FakeEntity>().Count());
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_no_AsNoTracking_method_does_nothing()
|
|
{
|
|
var mockQueryable = new Mock<IQueryable>().Object;
|
|
var afterAsNoTracking = mockQueryable.AsNoTracking();
|
|
|
|
Assert.Same(mockQueryable, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingable : IQueryable
|
|
{
|
|
INoTrackingable AsNoTracking();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsNoTracking_method_calls_that_method()
|
|
{
|
|
var mockQueryable = new Mock<INoTrackingable>(MockBehavior.Strict);
|
|
IQueryable source = mockQueryable.Object;
|
|
var result = new Mock<INoTrackingable>().Object;
|
|
mockQueryable.Setup(i => i.AsNoTracking()).Returns(result);
|
|
|
|
var afterAsNoTracking = source.AsNoTracking();
|
|
|
|
Assert.Same(result, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingableWithFunnyAsNoTracking : IQueryable
|
|
{
|
|
INoTrackingableWithFunnyAsNoTracking AsNoTracking(string buffy, string summers);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_non_matching_AsNoTracking_is_ignored()
|
|
{
|
|
IQueryable source = new Mock<INoTrackingableWithFunnyAsNoTracking>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsNoTracking = source.AsNoTracking();
|
|
|
|
Assert.Same(source, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingableReturningVoid : IQueryable
|
|
{
|
|
void AsNoTracking();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_void_AsNoTracking_method_is_ignored()
|
|
{
|
|
var mockQueryable = new Mock<INoTrackingableReturningVoid>(MockBehavior.Strict);
|
|
|
|
var afterAsNoTracking = ((IQueryable)mockQueryable.Object).AsNoTracking();
|
|
|
|
Assert.Same(mockQueryable.Object, afterAsNoTracking);
|
|
}
|
|
|
|
public interface INoTrackingableReturningString : IQueryable
|
|
{
|
|
string AsNoTracking();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsNoTracking_returning_string_is_ignored()
|
|
{
|
|
IQueryable source = new Mock<INoTrackingableReturningString>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsNoTracking = source.AsNoTracking();
|
|
|
|
Assert.Same(source, afterAsNoTracking);
|
|
}
|
|
}
|
|
|
|
public class AsStreaming_Generic
|
|
{
|
|
[Fact]
|
|
public void With_null_source_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
"source", Assert.Throws<ArgumentNullException>(() => IQueryableExtensions.AsStreaming<FakeEntity>(null)).ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_ObjectQuery_returns_an_AsStreaming_one()
|
|
{
|
|
var query = MockHelper.CreateMockObjectQuery(new object()).Object;
|
|
|
|
var newQuery = query.AsStreaming();
|
|
|
|
Assert.NotSame(query, newQuery);
|
|
Assert.False(query.Streaming);
|
|
Assert.True(((ObjectQuery<object>)newQuery).Streaming);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IEnumerable_does_nothing()
|
|
{
|
|
var enumerable = new List<FakeEntity>
|
|
{
|
|
new FakeEntity(),
|
|
new FakeEntity(),
|
|
new FakeEntity()
|
|
}.AsQueryable();
|
|
var afterAsStreaming = enumerable.AsStreaming();
|
|
|
|
Assert.Same(enumerable, afterAsStreaming);
|
|
Assert.Equal(3, afterAsStreaming.Count());
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_no_AsStreaming_method_does_nothing()
|
|
{
|
|
var mockQueryable = new Mock<IQueryable<FakeEntity>>().Object;
|
|
var afterAsStreaming = mockQueryable.AsStreaming();
|
|
|
|
Assert.Same(mockQueryable, afterAsStreaming);
|
|
}
|
|
|
|
public interface IAsStreamable<T> : IQueryable<T>
|
|
{
|
|
IAsStreamable<T> AsStreaming();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsStreaming_method_calls_that_method()
|
|
{
|
|
var mockQueryable = new Mock<IAsStreamable<FakeEntity>>(MockBehavior.Strict);
|
|
IQueryable<FakeEntity> source = mockQueryable.Object;
|
|
var result = new Mock<IAsStreamable<FakeEntity>>().Object;
|
|
mockQueryable.Setup(i => i.AsStreaming()).Returns(result);
|
|
|
|
var afterAsStreaming = source.AsStreaming();
|
|
|
|
Assert.Same(result, afterAsStreaming);
|
|
}
|
|
|
|
public interface IAsStreamableWithFunnyAsStreaming<T> : IQueryable<T>
|
|
{
|
|
IAsStreamableWithFunnyAsStreaming<T> AsStreaming(string buffy, string summers);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_non_matching_AsStreaming_is_ignored()
|
|
{
|
|
IQueryable<FakeEntity> source = new Mock<IAsStreamableWithFunnyAsStreaming<FakeEntity>>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsStreaming = source.AsStreaming();
|
|
|
|
Assert.Same(source, afterAsStreaming);
|
|
}
|
|
|
|
public interface IAsStreamableReturningVoid<T> : IQueryable<T>
|
|
{
|
|
void AsStreaming();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_void_AsStreaming_method_is_ignored()
|
|
{
|
|
var mockQueryable = new Mock<IAsStreamableReturningVoid<FakeEntity>>(MockBehavior.Strict);
|
|
|
|
var afterAsStreaming = ((IQueryable<FakeEntity>)mockQueryable.Object).AsStreaming();
|
|
|
|
Assert.Same(mockQueryable.Object, afterAsStreaming);
|
|
}
|
|
|
|
public interface IAsStreamableReturningString<T> : IQueryable<T>
|
|
{
|
|
string AsStreaming();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsStreaming_returning_string_is_ignored()
|
|
{
|
|
IQueryable<FakeEntity> source = new Mock<IAsStreamableReturningString<FakeEntity>>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsStreaming = source.AsStreaming();
|
|
|
|
Assert.Same(source, afterAsStreaming);
|
|
}
|
|
}
|
|
|
|
public class AsStreaming_NonGeneric
|
|
{
|
|
[Fact]
|
|
public void With_null_source_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal("source", Assert.Throws<ArgumentNullException>(() => IQueryableExtensions.AsStreaming(null)).ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_ObjectQuery_returns_an_AsStreaming_one()
|
|
{
|
|
var query = (ObjectQuery)MockHelper.CreateMockObjectQuery(new object()).Object;
|
|
|
|
var newQuery = query.AsStreaming();
|
|
|
|
Assert.NotSame(query, newQuery);
|
|
Assert.False(query.Streaming);
|
|
Assert.True(((ObjectQuery)newQuery).Streaming);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IEnumerable_does_nothing()
|
|
{
|
|
var enumerable = (IQueryable)new List<FakeEntity>
|
|
{
|
|
new FakeEntity(),
|
|
new FakeEntity(),
|
|
new FakeEntity()
|
|
}.AsQueryable();
|
|
var afterAsStreaming = enumerable.AsStreaming();
|
|
|
|
Assert.Same(enumerable, afterAsStreaming);
|
|
Assert.Equal(3, afterAsStreaming.ToList<FakeEntity>().Count());
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_no_AsStreaming_method_does_nothing()
|
|
{
|
|
var mockQueryable = new Mock<IQueryable>().Object;
|
|
var afterAsStreaming = mockQueryable.AsStreaming();
|
|
|
|
Assert.Same(mockQueryable, afterAsStreaming);
|
|
}
|
|
|
|
public interface IStreamable : IQueryable
|
|
{
|
|
IStreamable AsStreaming();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsStreaming_method_calls_that_method()
|
|
{
|
|
var mockQueryable = new Mock<IStreamable>(MockBehavior.Strict);
|
|
IQueryable source = mockQueryable.Object;
|
|
var result = new Mock<IStreamable>().Object;
|
|
mockQueryable.Setup(i => i.AsStreaming()).Returns(result);
|
|
|
|
var afterAsStreaming = source.AsStreaming();
|
|
|
|
Assert.Same(result, afterAsStreaming);
|
|
}
|
|
|
|
public interface IAsStreamableWithFunnyAsStreaming : IQueryable
|
|
{
|
|
IAsStreamableWithFunnyAsStreaming AsStreaming(string buffy, string summers);
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_non_matching_AsStreaming_is_ignored()
|
|
{
|
|
IQueryable source = new Mock<IAsStreamableWithFunnyAsStreaming>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsStreaming = source.AsStreaming();
|
|
|
|
Assert.Same(source, afterAsStreaming);
|
|
}
|
|
|
|
public interface IAsStreamableReturningVoid : IQueryable
|
|
{
|
|
void AsStreaming();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_void_AsStreaming_method_is_ignored()
|
|
{
|
|
var mockQueryable = new Mock<IAsStreamableReturningVoid>(MockBehavior.Strict);
|
|
|
|
var afterAsStreaming = ((IQueryable)mockQueryable.Object).AsStreaming();
|
|
|
|
Assert.Same(mockQueryable.Object, afterAsStreaming);
|
|
}
|
|
|
|
public interface IAsStreamableReturningString : IQueryable
|
|
{
|
|
string AsStreaming();
|
|
}
|
|
|
|
[Fact]
|
|
public void On_IQueryable_with_AsStreaming_returning_string_is_ignored()
|
|
{
|
|
IQueryable source = new Mock<IAsStreamableReturningString>(MockBehavior.Strict).Object;
|
|
|
|
var afterAsStreaming = source.AsStreaming();
|
|
|
|
Assert.Same(source, afterAsStreaming);
|
|
}
|
|
}
|
|
|
|
public class Include_Generic
|
|
{
|
|
[Fact]
|
|
public void String_Include_with_null_string_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
Strings.ArgumentIsNullOrWhitespace("path"),
|
|
Assert.Throws<ArgumentException>(() =>
|
|
IQueryableExtensions.Include(new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object), null)).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_with_empty_string_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
Strings.ArgumentIsNullOrWhitespace("path"),
|
|
Assert.Throws<ArgumentException>(() =>
|
|
IQueryableExtensions.Include(new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object), "")).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_with_whitespace_string_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
Strings.ArgumentIsNullOrWhitespace("path"),
|
|
Assert.Throws<ArgumentException>(() =>
|
|
IQueryableExtensions.Include(new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object), " ")).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_with_null_source_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
"source", Assert.Throws<ArgumentNullException>(() =>
|
|
IQueryableExtensions.Include<FakeEntity>(null, "SomePath")).ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_on_IEnumerable_does_nothing()
|
|
{
|
|
var enumerable = new List<FakeEntity>
|
|
{
|
|
new FakeEntity(),
|
|
new FakeEntity(),
|
|
new FakeEntity()
|
|
}.AsQueryable();
|
|
var afterInclude = enumerable.Include("FakeRelationship");
|
|
|
|
Assert.Same(enumerable, afterInclude);
|
|
Assert.Equal(3, afterInclude.Count());
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_on_IQueryable_with_no_Include_method_does_nothing()
|
|
{
|
|
var mockQueryable = new Mock<IQueryable<FakeEntity>>().Object;
|
|
var afterInclude = mockQueryable.Include("FakeRelationship");
|
|
|
|
Assert.Same(mockQueryable, afterInclude);
|
|
}
|
|
|
|
public interface IIncludable<T> : IQueryable<T>
|
|
{
|
|
IIncludable<T> Include(string path);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_on_IQueryable_with_Include_method_calls_that_method()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<FakeEntity>>(MockBehavior.Strict);
|
|
IQueryable<FakeEntity> source = mockQueryable.Object;
|
|
var result = new Mock<IIncludable<FakeEntity>>().Object;
|
|
mockQueryable.Setup(i => i.Include("FakeRelationship")).Returns(result);
|
|
|
|
var afterInclude = source.Include("FakeRelationship");
|
|
|
|
Assert.Same(result, afterInclude);
|
|
}
|
|
|
|
public interface IIncludableWithFunnyInclude<T> : IQueryable<T>
|
|
{
|
|
IIncludableWithFunnyInclude<T> Include(string buffy, string summers);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_on_IQueryable_with_non_matching_Include_is_ignored()
|
|
{
|
|
IQueryable<FakeEntity> source = new Mock<IIncludableWithFunnyInclude<FakeEntity>>(MockBehavior.Strict).Object;
|
|
|
|
var afterInclude = source.Include("FakeRelationship");
|
|
|
|
Assert.Same(source, afterInclude);
|
|
}
|
|
|
|
public interface IIncludableReturningVoid<T> : IQueryable<T>
|
|
{
|
|
void Include(string path);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_on_IQueryable_with_void_Include_method_is_ignored()
|
|
{
|
|
var mockQueryable = new Mock<IIncludableReturningVoid<FakeEntity>>(MockBehavior.Strict);
|
|
|
|
var afterInclude = ((IQueryable<FakeEntity>)mockQueryable.Object).Include("FakeRelationship");
|
|
|
|
Assert.Same(mockQueryable.Object, afterInclude);
|
|
}
|
|
|
|
public interface IIncludableReturningString<T> : IQueryable<T>
|
|
{
|
|
string Include(string path);
|
|
}
|
|
|
|
[Fact]
|
|
public void String_Include_on_IQueryable_with_Include_returning_string_is_ignored()
|
|
{
|
|
IQueryable<FakeEntity> source = new Mock<IIncludableReturningString<FakeEntity>>(MockBehavior.Strict).Object;
|
|
|
|
var afterInclude = source.Include("FakeRelationship");
|
|
|
|
Assert.Same(source, afterInclude);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_single_reference_property()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Reference);
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Reference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_single_collection_property()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Collection);
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Collection"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_reference_followed_by_reference()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Reference.Level2Reference);
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Reference.Level2Reference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_reference_followed_by_collection()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Reference.Level2Collection);
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Reference.Level2Collection"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_collection_followed_by_reference()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Collection.Select(l1 => l1.Level2Reference));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Collection.Level2Reference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_collection_followed_by_collection()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Collection.Select(l1 => l1.Level2Collection));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Collection.Level2Collection"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_reference_followed_by_reference_followed_by_reference()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Reference.Level2Reference.Level3Reference);
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Reference.Level2Reference.Level3Reference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_reference_followed_by_reference_followed_by_collection()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Reference.Level2Reference.Level3Collection);
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Reference.Level2Reference.Level3Collection"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_reference_followed_by_collection_followed_by_reference()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Reference.Level2Collection.Select(l2 => l2.Level3Reference));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Reference.Level2Collection.Level3Reference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_reference_followed_by_collection_followed_by_collection()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Reference.Level2Collection.Select(l2 => l2.Level3Collection));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Reference.Level2Collection.Level3Collection"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_collection_followed_by_reference_followed_by_reference()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Collection.Select(l1 => l1.Level2Reference.Level3Reference));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Collection.Level2Reference.Level3Reference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_collection_followed_by_reference_followed_by_collection()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Collection.Select(l1 => l1.Level2Reference.Level3Collection));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Collection.Level2Reference.Level3Collection"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_collection_followed_by_collection_followed_by_reference()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Collection.Select(l1 => l1.Level2Collection.Select(l2 => l2.Level3Reference)));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Collection.Level2Collection.Level3Reference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_collection_followed_by_collection_followed_by_collection()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(e => e.Level1Collection.Select(l1 => l1.Level2Collection.Select(l2 => l2.Level3Collection)));
|
|
|
|
mockQueryable.Verify(i => i.Include("Level1Collection.Level2Collection.Level3Collection"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_can_parse_a_huge_funky_include_path()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable<RootEntity>>();
|
|
|
|
mockQueryable.Object.Include(
|
|
e =>
|
|
e.RootReference.RootCollection.Select(
|
|
r =>
|
|
r.Level1Reference.RootReference.Level1Collection.Select(
|
|
l1 =>
|
|
l1.Level2Collection.Select(
|
|
l2 => l2.Level3Collection.Select(l3 => l3.Level2Reference.Level1Collection.Select(l1b => l1b.RootReference))))));
|
|
|
|
mockQueryable.Verify(
|
|
i =>
|
|
i.Include(
|
|
"RootReference.RootCollection.Level1Reference.RootReference.Level1Collection.Level2Collection.Level3Collection.Level2Reference.Level1Collection.RootReference"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_with_null_source_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
"source",
|
|
Assert.Throws<ArgumentNullException>(() => IQueryableExtensions.Include<FakeEntity, int>(null, e => e.Id)).ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_with_null_expression_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
"path",
|
|
Assert.Throws<ArgumentNullException>(() => new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object).Include((Expression<Func<RootEntity, object>>)null)).ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_throws_when_given_fundamentaly_wrong_expression()
|
|
{
|
|
Assert.Equal(
|
|
new ArgumentException(Strings.DbExtensions_InvalidIncludePathExpression, "path").Message,
|
|
Assert.Throws<ArgumentException>(() =>
|
|
new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object).Include(e => new object())).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_throws_when_given_method_call_expression()
|
|
{
|
|
Assert.Equal(
|
|
new ArgumentException(Strings.DbExtensions_InvalidIncludePathExpression, "path").Message,
|
|
Assert.Throws<ArgumentException>(() =>
|
|
new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object).Include(e => e.GetType())).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_throws_when_given_second_level_method_call_expression()
|
|
{
|
|
Assert.Equal(
|
|
new ArgumentException(Strings.DbExtensions_InvalidIncludePathExpression, "path").Message,
|
|
Assert.Throws<ArgumentException>(() =>
|
|
new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object).Include(e => e.Level1Reference.GetType())).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_throws_when_given_first_level_method_call_with_second_level_property()
|
|
{
|
|
Assert.Equal(
|
|
new ArgumentException(Strings.DbExtensions_InvalidIncludePathExpression, "path").Message,
|
|
Assert.Throws<ArgumentException>(() =>
|
|
new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object).Include(e => e.Level1Reference.GetType().Assembly)).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_throws_when_given_call_to_something_other_than_Select()
|
|
{
|
|
Assert.Equal(
|
|
new ArgumentException(Strings.DbExtensions_InvalidIncludePathExpression, "path").Message,
|
|
Assert.Throws<ArgumentException>(() =>
|
|
new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object).Include(e => e.Level1Collection.First())).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_throws_when_given_second_level_call_to_something_other_than_Select()
|
|
{
|
|
Assert.Equal(
|
|
new ArgumentException(Strings.DbExtensions_InvalidIncludePathExpression, "path").Message,
|
|
Assert.Throws<ArgumentException>(() =>
|
|
new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object)
|
|
.Include(e => e.Level1Collection.Select(l1 => l1.Level2Collection.Distinct()))).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Lambda_Include_throws_when_given_first_level_call_to_something_other_than_Select_containing_expression()
|
|
{
|
|
Assert.Equal(
|
|
new ArgumentException(Strings.DbExtensions_InvalidIncludePathExpression, "path").Message,
|
|
Assert.Throws<ArgumentException>(() =>
|
|
new DbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object)
|
|
.Include(e => e.Level1Collection.Any(l1 => l1.BoolProperty))).Message);
|
|
}
|
|
}
|
|
|
|
public class Include_NonGeneric
|
|
{
|
|
[Fact]
|
|
public void Non_generic_String_Include_with_null_string_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
Strings.ArgumentIsNullOrWhitespace("path"),
|
|
Assert.Throws<ArgumentException>(() =>
|
|
IQueryableExtensions.Include(new InternalDbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object), null)).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_with_empty_string_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
Strings.ArgumentIsNullOrWhitespace("path"),
|
|
Assert.Throws<ArgumentException>(() =>
|
|
IQueryableExtensions.Include(new InternalDbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object), "")).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_with_whitespace_string_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal(
|
|
Strings.ArgumentIsNullOrWhitespace("path"),
|
|
Assert.Throws<ArgumentException>(() =>
|
|
IQueryableExtensions.Include(new InternalDbQuery<RootEntity>(new Mock<IInternalQuery<RootEntity>>().Object), " ")).Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_with_null_source_called_on_extension_method_throws()
|
|
{
|
|
Assert.Equal("source", Assert.Throws<ArgumentNullException>(() => IQueryableExtensions.Include(null, "SomePath")).ParamName);
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_on_IEnumerable_does_nothing()
|
|
{
|
|
var enumerable = (IQueryable)new List<FakeEntity>
|
|
{
|
|
new FakeEntity(),
|
|
new FakeEntity(),
|
|
new FakeEntity()
|
|
}.AsQueryable();
|
|
var afterInclude = enumerable.Include("FakeRelationship");
|
|
|
|
Assert.Same(enumerable, afterInclude);
|
|
Assert.Equal(3, afterInclude.ToList<FakeEntity>().Count());
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_on_IQueryable_with_no_Include_method_does_nothing()
|
|
{
|
|
var mockQueryable = new Mock<IQueryable>().Object;
|
|
var afterInclude = mockQueryable.Include("FakeRelationship");
|
|
|
|
Assert.Same(mockQueryable, afterInclude);
|
|
}
|
|
|
|
public interface IIncludable : IQueryable
|
|
{
|
|
IIncludable Include(string path);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_on_IQueryable_with_Include_method_calls_that_method()
|
|
{
|
|
var mockQueryable = new Mock<IIncludable>(MockBehavior.Strict);
|
|
IQueryable source = mockQueryable.Object;
|
|
var result = new Mock<IIncludable>().Object;
|
|
mockQueryable.Setup(i => i.Include("FakeRelationship")).Returns(result);
|
|
|
|
var afterInclude = source.Include("FakeRelationship");
|
|
|
|
Assert.Same(result, afterInclude);
|
|
}
|
|
|
|
public interface IIncludableWithFunnyInclude : IQueryable
|
|
{
|
|
IIncludableWithFunnyInclude Include(string buffy, string summers);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_on_IQueryable_with_non_matching_Include_is_ignored()
|
|
{
|
|
IQueryable source = new Mock<IIncludableWithFunnyInclude>(MockBehavior.Strict).Object;
|
|
|
|
var afterInclude = source.Include("FakeRelationship");
|
|
|
|
Assert.Same(source, afterInclude);
|
|
}
|
|
|
|
public interface IIncludableReturningVoid : IQueryable
|
|
{
|
|
void Include(string path);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_on_IQueryable_with_void_Include_method_is_ignored()
|
|
{
|
|
var mockQueryable = new Mock<IIncludableReturningVoid>(MockBehavior.Strict);
|
|
|
|
var afterInclude = ((IQueryable)mockQueryable.Object).Include("FakeRelationship");
|
|
|
|
Assert.Same(mockQueryable.Object, afterInclude);
|
|
}
|
|
|
|
public interface IIncludableReturningString : IQueryable
|
|
{
|
|
string Include(string path);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_generic_String_Include_on_IQueryable_with_Include_returning_string_is_ignored()
|
|
{
|
|
IQueryable source = new Mock<IIncludableReturningString>(MockBehavior.Strict).Object;
|
|
|
|
var afterInclude = source.Include("FakeRelationship");
|
|
|
|
Assert.Same(source, afterInclude);
|
|
}
|
|
}
|
|
|
|
#region Async equivalents of IQueryable extension methods
|
|
|
|
#if !NET40
|
|
|
|
[Fact]
|
|
public void Extension_methods_validate_arguments()
|
|
{
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().FirstAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().FirstAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstOrDefaultAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstOrDefaultAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstOrDefaultAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.FirstOrDefaultAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().FirstOrDefaultAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().FirstOrDefaultAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().SingleAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().SingleAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleOrDefaultAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleOrDefaultAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleOrDefaultAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.SingleOrDefaultAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().SingleOrDefaultAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().SingleOrDefaultAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.ContainsAsync(null, 1));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.ContainsAsync(null, 1, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.AnyAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.AnyAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.AnyAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.AnyAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().AnyAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().AnyAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.AllAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.AllAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().AllAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().AllAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.CountAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.CountAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.CountAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.CountAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().CountAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().CountAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.LongCountAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.LongCountAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.LongCountAsync<int>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.LongCountAsync<int>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("predicate", () => Source().LongCountAsync(null));
|
|
ArgumentNullTest("predicate", () => Source().LongCountAsync(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MinAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MinAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MinAsync<int, bool>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MinAsync<int, bool>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source().MinAsync<int, bool>(null));
|
|
ArgumentNullTest("selector", () => Source().MinAsync<int, bool>(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MaxAsync<int>(null));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MaxAsync<int>(null, new CancellationToken()));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MaxAsync<int, bool>(null, s => true));
|
|
ArgumentNullTest("source", () => IQueryableExtensions.MaxAsync<int, bool>(null, s => true, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source().MaxAsync<int, bool>(null));
|
|
ArgumentNullTest("selector", () => Source().MaxAsync<int, bool>(null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).SumAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).SumAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).SumAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).SumAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<int>().SumAsync((Expression<Func<int, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<int>().SumAsync((Expression<Func<int, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<int?>().SumAsync((Expression<Func<int?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<int?>().SumAsync((Expression<Func<int?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<long>().SumAsync((Expression<Func<long, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<long>().SumAsync((Expression<Func<long, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<long?>().SumAsync((Expression<Func<long?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<long?>().SumAsync((Expression<Func<long?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<float>().SumAsync((Expression<Func<float, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<float>().SumAsync((Expression<Func<float, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<float?>().SumAsync((Expression<Func<float?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<float?>().SumAsync((Expression<Func<float?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<double>().SumAsync((Expression<Func<double, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<double>().SumAsync((Expression<Func<double, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<double?>().SumAsync((Expression<Func<double?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<double?>().SumAsync((Expression<Func<double?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<decimal>().SumAsync((Expression<Func<decimal, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<decimal>().SumAsync((Expression<Func<decimal, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<decimal?>().SumAsync((Expression<Func<decimal?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<decimal?>().SumAsync((Expression<Func<decimal?, int>>)null, new CancellationToken()));
|
|
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).AverageAsync());
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).AverageAsync(new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<int>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<int?>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<long>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<long?>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<float>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<float?>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<double>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<double?>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).AverageAsync(i => 0));
|
|
ArgumentNullTest("source", () => ((IQueryable<decimal?>)null).AverageAsync(i => 0, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<int>().AverageAsync((Expression<Func<int, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<int>().AverageAsync((Expression<Func<int, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<int?>().AverageAsync((Expression<Func<int?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<int?>().AverageAsync((Expression<Func<int?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<long>().AverageAsync((Expression<Func<long, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<long>().AverageAsync((Expression<Func<long, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<long?>().AverageAsync((Expression<Func<long?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<long?>().AverageAsync((Expression<Func<long?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<float>().AverageAsync((Expression<Func<float, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<float>().AverageAsync((Expression<Func<float, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<float?>().AverageAsync((Expression<Func<float?, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<float?>().AverageAsync((Expression<Func<float?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<double>().AverageAsync((Expression<Func<double, int>>)null));
|
|
ArgumentNullTest("selector", () => Source<double>().AverageAsync((Expression<Func<double, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<double?>().AverageAsync((Expression<Func<double?, int>>)null));
|
|
ArgumentNullTest(
|
|
"selector", () => Source<double?>().AverageAsync((Expression<Func<double?, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<decimal>().AverageAsync((Expression<Func<decimal, int>>)null));
|
|
ArgumentNullTest(
|
|
"selector", () => Source<decimal>().AverageAsync((Expression<Func<decimal, int>>)null, new CancellationToken()));
|
|
ArgumentNullTest("selector", () => Source<decimal?>().AverageAsync((Expression<Func<decimal?, int>>)null));
|
|
ArgumentNullTest(
|
|
"selector", () => Source<decimal?>().AverageAsync((Expression<Func<decimal?, int>>)null, new CancellationToken()));
|
|
}
|
|
|
|
[Fact]
|
|
public void Extension_methods_throw_on_non_async_source()
|
|
{
|
|
SourceNonAsyncQueryableTest(() => Source().AllAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().AllAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().AnyAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().AnyAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().AnyAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().AnyAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source<int>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<int>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<int>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<int>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<long>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<long>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<float>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<float>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<double>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<double>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().AverageAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().AverageAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().AverageAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().AverageAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().AverageAsync(e => e, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().ContainsAsync(0));
|
|
SourceNonAsyncQueryableTest(() => Source().ContainsAsync(0, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().CountAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().CountAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().CountAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().CountAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().FirstAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().FirstAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().FirstAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().FirstAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().FirstOrDefaultAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().FirstOrDefaultAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().FirstOrDefaultAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().FirstOrDefaultAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ForEachAsync(e => e.GetType()));
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ForEachAsync(e => e.GetType(), new CancellationToken()));
|
|
|
|
SourceNonAsyncEnumerableTest(() => Source().LoadAsync());
|
|
SourceNonAsyncEnumerableTest(() => Source().LoadAsync(new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().LongCountAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().LongCountAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().LongCountAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().LongCountAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().MaxAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().MaxAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().MaxAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source().MaxAsync(e => e, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().MinAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().MinAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().MinAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source().MinAsync(e => e, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().SingleAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().SingleAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().SingleAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().SingleAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source().SingleOrDefaultAsync());
|
|
SourceNonAsyncQueryableTest(() => Source().SingleOrDefaultAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source().SingleOrDefaultAsync(e => true));
|
|
SourceNonAsyncQueryableTest(() => Source().SingleOrDefaultAsync(e => true, new CancellationToken()));
|
|
|
|
SourceNonAsyncQueryableTest(() => Source<int>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<int>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<int>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<int>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<int?>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<long>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<long>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<long?>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<float>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<float>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<float?>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<double>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<double>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<double?>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal>().SumAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().SumAsync());
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().SumAsync(new CancellationToken()));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().SumAsync(e => e));
|
|
SourceNonAsyncQueryableTest(() => Source<decimal?>().SumAsync(e => e, new CancellationToken()));
|
|
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToArrayAsync());
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToArrayAsync(new CancellationToken()));
|
|
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToDictionaryAsync(e => e));
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToDictionaryAsync(e => e, new CancellationToken()));
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToDictionaryAsync(e => e, e => e));
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToDictionaryAsync(e => e, e => e, new CancellationToken()));
|
|
SourceNonAsyncEnumerableTest<int>(
|
|
() => Source().ToDictionaryAsync(
|
|
e => e,
|
|
new Mock<IEqualityComparer<int>>().Object));
|
|
SourceNonAsyncEnumerableTest<int>(
|
|
() => Source().ToDictionaryAsync(
|
|
e => e,
|
|
new Mock<IEqualityComparer<int>>().Object, new CancellationToken()));
|
|
SourceNonAsyncEnumerableTest<int>(
|
|
() => Source().ToDictionaryAsync(
|
|
e => e, e => e,
|
|
new Mock<IEqualityComparer<int>>().Object));
|
|
SourceNonAsyncEnumerableTest<int>(
|
|
() => Source().ToDictionaryAsync(
|
|
e => e, e => e,
|
|
new Mock<IEqualityComparer<int>>().Object, new CancellationToken()));
|
|
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToListAsync());
|
|
SourceNonAsyncEnumerableTest<int>(() => Source().ToListAsync(new CancellationToken()));
|
|
|
|
SourceNonAsyncEnumerableTest(() => ((IQueryable)Source()).ForEachAsync(e => e.GetType()));
|
|
SourceNonAsyncEnumerableTest(() => ((IQueryable)Source()).ForEachAsync(e => e.GetType(), new CancellationToken()));
|
|
|
|
SourceNonAsyncEnumerableTest(() => (Source()).ToListAsync<double>());
|
|
SourceNonAsyncEnumerableTest(() => (Source()).ToListAsync<double>(new CancellationToken()));
|
|
}
|
|
|
|
[Fact]
|
|
public void Extension_methods_call_provider_ExecuteAsync()
|
|
{
|
|
var cancellationTokenSource = new CancellationTokenSource();
|
|
VerifyProducedExpression<int, bool>(value => value.AllAsync(e => true));
|
|
VerifyProducedExpression<int, bool>(value => value.AllAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, bool>(value => value.AnyAsync());
|
|
VerifyProducedExpression<int, bool>(value => value.AnyAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, bool>(value => value.AnyAsync(e => true));
|
|
VerifyProducedExpression<int, bool>(value => value.AnyAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, double>(value => value.AverageAsync());
|
|
VerifyProducedExpression<int, double>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, double>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<int, double>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int?, double?>(value => value.AverageAsync());
|
|
VerifyProducedExpression<int?, double?>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int?, double?>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<int?, double?>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long, double>(value => value.AverageAsync());
|
|
VerifyProducedExpression<long, double>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long, double>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<long, double>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long?, double?>(value => value.AverageAsync());
|
|
VerifyProducedExpression<long?, double?>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long?, double?>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<long?, double?>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float, float>(value => value.AverageAsync());
|
|
VerifyProducedExpression<float, float>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float, float>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<float, float>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float?, float?>(value => value.AverageAsync());
|
|
VerifyProducedExpression<float?, float?>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float?, float?>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<float?, float?>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double, double>(value => value.AverageAsync());
|
|
VerifyProducedExpression<double, double>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double, double>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<double, double>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double?, double?>(value => value.AverageAsync());
|
|
VerifyProducedExpression<double?, double?>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double?, double?>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<double?, double?>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal, decimal>(value => value.AverageAsync());
|
|
VerifyProducedExpression<decimal, decimal>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal, decimal>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<decimal, decimal>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.AverageAsync());
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.AverageAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.AverageAsync(e => e));
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.AverageAsync(e => e, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, bool>(value => value.ContainsAsync(0));
|
|
VerifyProducedExpression<int, bool>(value => value.ContainsAsync(0, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.CountAsync());
|
|
VerifyProducedExpression<int, int>(value => value.CountAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.CountAsync(e => true));
|
|
VerifyProducedExpression<int, int>(value => value.CountAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.FirstAsync());
|
|
VerifyProducedExpression<int, int>(value => value.FirstAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.FirstAsync(e => true));
|
|
VerifyProducedExpression<int, int>(value => value.FirstAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.FirstOrDefaultAsync());
|
|
VerifyProducedExpression<int, int>(value => value.FirstOrDefaultAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.FirstOrDefaultAsync(e => true));
|
|
VerifyProducedExpression<int, int>(value => value.FirstOrDefaultAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, long>(value => value.LongCountAsync());
|
|
VerifyProducedExpression<int, long>(value => value.LongCountAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, long>(value => value.LongCountAsync(e => true));
|
|
VerifyProducedExpression<int, long>(value => value.LongCountAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.MaxAsync());
|
|
VerifyProducedExpression<int, int>(value => value.MaxAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.MaxAsync(e => e));
|
|
VerifyProducedExpression<int, int>(value => value.MaxAsync(e => e, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.MinAsync());
|
|
VerifyProducedExpression<int, int>(value => value.MinAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.MinAsync(e => e));
|
|
VerifyProducedExpression<int, int>(value => value.MinAsync(e => e, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.SingleAsync());
|
|
VerifyProducedExpression<int, int>(value => value.SingleAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.SingleAsync(e => true));
|
|
VerifyProducedExpression<int, int>(value => value.SingleAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.SingleOrDefaultAsync());
|
|
VerifyProducedExpression<int, int>(value => value.SingleOrDefaultAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.SingleOrDefaultAsync(e => true));
|
|
VerifyProducedExpression<int, int>(value => value.SingleOrDefaultAsync(e => true, cancellationTokenSource.Token));
|
|
|
|
VerifyProducedExpression<int, int>(value => value.SumAsync());
|
|
VerifyProducedExpression<int, int>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int, int>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<int, int>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int?, int?>(value => value.SumAsync());
|
|
VerifyProducedExpression<int?, int?>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<int?, int?>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<int?, int?>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long, long>(value => value.SumAsync());
|
|
VerifyProducedExpression<long, long>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long, long>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<long, long>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long?, long?>(value => value.SumAsync());
|
|
VerifyProducedExpression<long?, long?>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<long?, long?>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<long?, long?>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float, float>(value => value.SumAsync());
|
|
VerifyProducedExpression<float, float>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float, float>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<float, float>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float?, float?>(value => value.SumAsync());
|
|
VerifyProducedExpression<float?, float?>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<float?, float?>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<float?, float?>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double, double>(value => value.SumAsync());
|
|
VerifyProducedExpression<double, double>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double, double>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<double, double>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double?, double?>(value => value.SumAsync());
|
|
VerifyProducedExpression<double?, double?>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<double?, double?>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<double?, double?>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal, decimal>(value => value.SumAsync());
|
|
VerifyProducedExpression<decimal, decimal>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal, decimal>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<decimal, decimal>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.SumAsync());
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.SumAsync(cancellationTokenSource.Token));
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.SumAsync(e => e));
|
|
VerifyProducedExpression<decimal?, decimal?>(value => value.SumAsync(e => e, cancellationTokenSource.Token));
|
|
}
|
|
|
|
private static IQueryable<T> Source<T>()
|
|
{
|
|
return new Mock<IQueryable<T>>().Object;
|
|
}
|
|
|
|
private static IQueryable<int> Source()
|
|
{
|
|
return Source<int>();
|
|
}
|
|
|
|
private static void ArgumentNullTest(string paramName, Action test)
|
|
{
|
|
Assert.Equal(paramName, Assert.Throws<ArgumentNullException>(() => test()).ParamName);
|
|
}
|
|
|
|
private static void SourceNonAsyncQueryableTest(Action test)
|
|
{
|
|
Assert.Equal(Strings.IQueryable_Provider_Not_Async, Assert.Throws<InvalidOperationException>(() => test()).Message);
|
|
}
|
|
|
|
private static void SourceNonAsyncEnumerableTest(Action test)
|
|
{
|
|
Assert.Equal(Strings.IQueryable_Not_Async(string.Empty), Assert.Throws<InvalidOperationException>(() => test()).Message);
|
|
}
|
|
|
|
private static void SourceNonAsyncEnumerableTest<T>(Action test)
|
|
{
|
|
Assert.Equal(
|
|
Strings.IQueryable_Not_Async("<" + typeof(T) + ">"), Assert.Throws<InvalidOperationException>(() => test()).Message);
|
|
}
|
|
|
|
private static void VerifyProducedExpression<TElement, TResult>(
|
|
Expression<Func<IQueryable<TElement>, Task<TResult>>> testExpression)
|
|
{
|
|
var queryableMock = new Mock<IQueryable<TElement>>();
|
|
var providerMock = new Mock<IDbAsyncQueryProvider>();
|
|
providerMock.Setup(m => m.ExecuteAsync<TResult>(It.IsAny<Expression>(), It.IsAny<CancellationToken>()))
|
|
.Returns<Expression, CancellationToken>(
|
|
(e, ct) =>
|
|
{
|
|
var expectedMethodCall = (MethodCallExpression)testExpression.Body;
|
|
var actualMethodCall = (MethodCallExpression)e;
|
|
|
|
Assert.Equal(
|
|
expectedMethodCall.Method.Name,
|
|
actualMethodCall.Method.Name + "Async");
|
|
|
|
var lastArgument =
|
|
expectedMethodCall.Arguments[expectedMethodCall.Arguments.Count - 1] as MemberExpression;
|
|
|
|
var cancellationTokenPresent = lastArgument != null && lastArgument.Type == typeof(CancellationToken);
|
|
|
|
if (cancellationTokenPresent)
|
|
{
|
|
Assert.NotEqual(ct, CancellationToken.None);
|
|
}
|
|
else
|
|
{
|
|
Assert.Equal(ct, CancellationToken.None);
|
|
}
|
|
|
|
var expectedNumberOfArguments = cancellationTokenPresent
|
|
? expectedMethodCall.Arguments.Count - 1
|
|
: expectedMethodCall.Arguments.Count;
|
|
Assert.Equal(expectedNumberOfArguments, actualMethodCall.Arguments.Count);
|
|
for (var i = 1; i < expectedNumberOfArguments; i++)
|
|
{
|
|
var expectedArgument = expectedMethodCall.Arguments[i];
|
|
var actualArgument = actualMethodCall.Arguments[i];
|
|
Assert.Equal(expectedArgument.ToString(), actualArgument.ToString());
|
|
}
|
|
|
|
return Task.FromResult(default(TResult));
|
|
});
|
|
|
|
queryableMock.Setup(m => m.Provider).Returns(providerMock.Object);
|
|
|
|
queryableMock.Setup(m => m.Expression).Returns(Expression.Constant(queryableMock.Object, typeof(IQueryable<TElement>)));
|
|
|
|
testExpression.Compile()(queryableMock.Object);
|
|
}
|
|
|
|
#endif
|
|
|
|
#endregion
|
|
}
|
|
}
|