public void CanTranslateThenFetchCollectionClause()
{
var session = new Mock <ISession>();
var executor = new SpecificationExecutor();
var specification = new WithThenFetchCollection();
var queryable = executor.ExecuteSpecification(session.Object, specification);
var thenFetchManyMethodInfo = ReflectionHelper.FindMethod(
BindingFlags.Static | BindingFlags.Public,
typeof(EagerFetchingExtensionMethods),
nameof(EagerFetchingExtensionMethods.ThenFetchMany),
null,
new ArgumentConstraint(typeof(INhFetchRequest <,>), 1),
new ArgumentConstraint(typeof(Expression <>).MakeGenericType(typeof(Func <,>)), 2));
var lambda = (MethodCallExpression)queryable.Expression;
Assert.Equal(ExpressionType.Call, lambda.NodeType);
Assert.Same(
thenFetchManyMethodInfo.MakeGenericMethod(typeof(User), typeof(Order), typeof(Good)),
lambda.Method);
Assert.Same(
specification.Expression.Body,
((UnaryExpression)((LambdaExpression)((UnaryExpression)lambda.Arguments.ElementAt(1)).Operand).Body).Operand);
}
public void CanTranslateOrderByClause()
{
var session = new Mock <ISession>();
var executor = new SpecificationExecutor();
var specification = new WithOrderBy();
var queryable = executor.ExecuteSpecification(session.Object, specification);
var orderByMethodInfo = ReflectionHelper.FindMethod(
BindingFlags.Static | BindingFlags.Public,
typeof(Queryable),
nameof(Queryable.OrderBy),
null,
new ArgumentConstraint(typeof(IQueryable <>), 1),
new ArgumentConstraint(typeof(Expression <>).MakeGenericType(typeof(Func <,>)), 2));
var lambda = (MethodCallExpression)queryable.Expression;
Assert.Equal(ExpressionType.Call, lambda.NodeType);
Assert.Same(
orderByMethodInfo.MakeGenericMethod(typeof(User), typeof(int)),
lambda.Method);
Assert.Same(
specification.Expression,
((UnaryExpression)lambda.Arguments.ElementAt(1)).Operand);
}
public void CanTranslateTakeClause()
{
var session = new Mock <ISession>();
var executor = new SpecificationExecutor();
var specification = new WithTake();
var queryable = executor.ExecuteSpecification(session.Object, specification);
var takeMethodInfo = ReflectionHelper.FindMethod(
BindingFlags.Static | BindingFlags.Public,
typeof(Queryable),
nameof(Queryable.Take),
null,
new ArgumentConstraint(typeof(IQueryable <>), 1),
new ArgumentConstraint(typeof(int), 1));
var lambda = (MethodCallExpression)queryable.Expression;
Assert.Equal(ExpressionType.Call, lambda.NodeType);
Assert.Same(
takeMethodInfo.MakeGenericMethod(typeof(User)),
lambda.Method);
Assert.Equal(
5,
((ConstantExpression)lambda.Arguments.ElementAt(1)).Value);
}
public void CanTranslateProjectionClause()
{
var context = new Mock <Context>();
context
.Setup(x => x.Set <User>())
.Returns(new FakeSet <User>());
var executor = new SpecificationExecutor();
var specification = new WithProjection();
var queryable = executor.ExecuteSpecification(context.Object, specification);
var selectMethodInfo = ReflectionHelper.FindMethod(
BindingFlags.Static | BindingFlags.Public,
typeof(Queryable),
nameof(Queryable.Select),
null,
new ArgumentConstraint(typeof(IQueryable <>), 1),
new ArgumentConstraint(typeof(Expression <>).MakeGenericType(typeof(Func <,>)), 2));
var lambda = (MethodCallExpression)queryable.Expression;
Assert.Equal(ExpressionType.Call, lambda.NodeType);
Assert.Same(
selectMethodInfo.MakeGenericMethod(typeof(User), typeof(int)),
lambda.Method);
Assert.Same(
specification.Expression,
((UnaryExpression)lambda.Arguments.ElementAt(1)).Operand);
}
public void CanTranslateThenFetchClause()
{
var context = new Mock <Context>();
context
.Setup(x => x.Set <User>())
.Returns(new FakeSet <User>());
var executor = new SpecificationExecutor();
var specification = new WithThenFetch();
var queryable = executor.ExecuteSpecification(context.Object, specification);
var thenFetchMethodInfo = typeof(EntityFrameworkQueryableExtensions)
.GetMethods(BindingFlags.Public | BindingFlags.Static)
.Where(x => x.Name == nameof(EntityFrameworkQueryableExtensions.ThenInclude))
.First(x =>
{
var arguments = x.GetParameters();
var includableQuerySecondArguments = arguments.First().ParameterType.GetGenericArguments().ElementAt(1);
return(!includableQuerySecondArguments.IsGenericType || !(typeof(IEnumerable <>).IsAssignableFrom(includableQuerySecondArguments.GetGenericTypeDefinition())));
});
var lambda = (MethodCallExpression)queryable.Expression;
Assert.Equal(ExpressionType.Call, lambda.NodeType);
Assert.Same(
thenFetchMethodInfo.MakeGenericMethod(typeof(User), typeof(Person), typeof(byte[])),
lambda.Method);
Assert.Same(
specification.Expression.Body,
((LambdaExpression)((UnaryExpression)lambda.Arguments.ElementAt(1)).Operand).Body);
}
public void CanTranslateThenFetchAfterCollectionClause()
{
var context = new Mock <Context>();
context
.Setup(x => x.Set <User>())
.Returns(new FakeSet <User>());
var executor = new SpecificationExecutor();
var specification = new WithThenFetchAfterCollection();
var queryable = executor.ExecuteSpecification(context.Object, specification);
var thenFetchAfterCollectionMethodInfo = ReflectionHelper.FindMethod(
BindingFlags.Static | BindingFlags.Public,
typeof(EntityFrameworkQueryableExtensions),
nameof(EntityFrameworkQueryableExtensions.ThenInclude),
null,
new ArgumentConstraint(typeof(IIncludableQueryable <,>), 1),
new ArgumentConstraint(typeof(Expression <>).MakeGenericType(typeof(Func <,>)), 2));
var lambda = (MethodCallExpression)queryable.Expression;
Assert.Equal(ExpressionType.Call, lambda.NodeType);
Assert.Same(
thenFetchAfterCollectionMethodInfo.MakeGenericMethod(typeof(User), typeof(Order), typeof(Address)),
lambda.Method);
Assert.Same(
specification.Expression,
((UnaryExpression)lambda.Arguments.ElementAt(1)).Operand);
}
public void CanTranslateJoinClause()
{
var context = new Mock <Context>();
context
.Setup(x => x.Set <User>())
.Returns(new FakeSet <User>());
var executor = new SpecificationExecutor();
var specification = new WithJoin();
var queryable = executor.ExecuteSpecification(context.Object, specification);
var subQuery = executor.CreateQueryable(context.Object, (Query)specification.SubQuery);
var joinMethodInfo = ReflectionHelper.FindMethod(
BindingFlags.Static | BindingFlags.Public,
typeof(Queryable),
nameof(Queryable.Join),
null,
new ArgumentConstraint(typeof(IQueryable <>), 1),
new ArgumentConstraint(typeof(IEnumerable <>), 1),
new ArgumentConstraint(typeof(Expression <>).MakeGenericType(typeof(Func <,>)), 2),
new ArgumentConstraint(typeof(Expression <>).MakeGenericType(typeof(Func <,>)), 2),
new ArgumentConstraint(typeof(Expression <>).MakeGenericType(typeof(Func <, ,>)), 2));
var lambda = (MethodCallExpression)queryable.Expression;
Assert.Equal(ExpressionType.Call, lambda.NodeType);
Assert.Same(
joinMethodInfo.MakeGenericMethod(
typeof(User),
typeof(User),
typeof(int),
typeof(WithJoin.Result)),
lambda.Method);
//Assert.AreEqual(
// subQuery.Expression,
// ((LambdaExpression)((UnaryExpression)lambda.Arguments.ElementAt(1)).Operand).Body);
Assert.Same(
specification.OuterKeySelector.Body,
((LambdaExpression)((UnaryExpression)lambda.Arguments.ElementAt(2)).Operand).Body);
Assert.Same(
specification.InnerKeySelector.Body,
((LambdaExpression)((UnaryExpression)lambda.Arguments.ElementAt(3)).Operand).Body);
Assert.Same(
specification.ResultSelector.Body,
((LambdaExpression)((UnaryExpression)lambda.Arguments.ElementAt(4)).Operand).Body);
}
