public void WhenParsingInputThenCreatesExpectedExpression(string input, string expected)
{
var filterFactory = new FilterExpressionFactory(new MemberNameResolver(), Enumerable.Empty <IValueExpressionFactory>());
var expression = filterFactory.Create <TypeInstanceData>(input);
Assert.AreEqual(expected, expression.ToString());
}
public void WhenApplyingSerializedExpressionThenCreatesSameResultAsOriginalExpressionWithNotFlagsEnumToNumberComparison()
{
Func <FakeItem, bool> original = x => x.NotFlagsValue == NotFlags.Fine && x.IntValue >= 3;
var factory = new FilterExpressionFactory(new MemberNameResolver(), Enumerable.Empty <IValueExpressionFactory>());
var deserialized = factory.Create <FakeItem>("NotFlagsValue eq 3 And IntValue ge 3");
var originalResult = _collection.Where(original).ToArray();
var deserializedResult = _collection.Where(deserialized.Compile()).ToArray();
Assert.True(originalResult.SequenceEqual(deserializedResult));
}
public void WhenApplyingSerializedExpressionThenCreatesSameResultAsOriginalExpressionWithEnumToNumberComparison()
{
Func<FakeItem, bool> original = x => (x.ChoiceValue & Choice.That) == Choice.That && x.IntValue >= 3;
var factory = new FilterExpressionFactory(new MemberNameResolver(), Enumerable.Empty<IValueExpressionFactory>());
var deserialized = factory.Create<FakeItem>("ChoiceValue eq 2 And IntValue ge 3");
var originalResult = _collection.Where(original).ToArray();
var deserializedResult = _collection.Where(deserialized.Compile()).ToArray();
Assert.True(originalResult.SequenceEqual(deserializedResult));
}
public void WhenApplyingSerializedExpressionThenCreatesSameResultAsOriginalExpression()
{
Func <FakeItem, bool> original = x => (x.ChoiceValue & Choice.That) == Choice.That && x.IntValue >= 3;
var factory = new FilterExpressionFactory(new MemberNameResolver(), Enumerable.Empty <IValueExpressionFactory>());
var deserialized = factory.Create <FakeItem>("ChoiceValue eq Linq2Rest.Tests.Choice'That' And IntValue ge 3");
var originalResult = _collection.Where(original).ToArray();
var deserializedResult = _collection.Where(deserialized.Compile()).ToArray();
Assert.True(originalResult.SequenceEqual(deserializedResult));
}
internal static IQbservable <T> Deserialize <T>(IQbservable <T> query, IEnumerable <ServiceQueryPart> queryParts)
{
Contract.Requires(query != null);
Contract.Requires(queryParts != null);
int?skip = null;
int?top = null;
foreach (ServiceQueryPart part in queryParts)
{
switch (part.QueryOperator)
{
case "filter":
FilterExpressionFactory filterExpressionFactory = new FilterExpressionFactory();
Expression <Func <T, bool> > expression = filterExpressionFactory.Create <T>(part.Expression);
query = query.Where(expression);
break;
case "orderby":
throw new NotSupportedException("The query operator 'orderby' is not supported for event streams");
case "skip":
int skipValue;
if (int.TryParse(part.Expression, out skipValue))
{
skip = skipValue;
}
break;
case "top":
int topValue;
if (int.TryParse(part.Expression, out topValue))
{
top = topValue;
}
break;
}
}
if (skip != null)
{
query = query.Skip(skip.Value);
}
if (top != null)
{
query = query.Take(top.Value);
}
return(query);
}
/// <summary>
/// To the query options.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="odataQueryOptions">The o data query options.</param>
/// <returns>QueryOptions{``0}.</returns>
public static QueryOptions <T> ToQueryOptions <T>(this ODataQueryOptions <T> odataQueryOptions)
{
if (odataQueryOptions == null)
{
return(null);
}
var nameResolver = new MemberNameResolver();
var selectFactory = new SelectExpressionFactory <T>(nameResolver, new RuntimeTypeProvider(nameResolver));
var filterFactiory = new FilterExpressionFactory(nameResolver, Enumerable.Empty <IValueExpressionFactory>());
var orderFactory = new SortExpressionFactory(nameResolver);
return(new QueryOptions <T>
{
Top = odataQueryOptions.Top?.Value,
Skip = odataQueryOptions.Skip?.Value,
Select =
!string.IsNullOrEmpty(odataQueryOptions.SelectExpand?.RawSelect)
? selectFactory.Create(odataQueryOptions.SelectExpand.RawSelect)
: null,
Expand =
!string.IsNullOrEmpty(odataQueryOptions.SelectExpand?.RawExpand)
? odataQueryOptions.SelectExpand.RawExpand.Split(',').ToList()
: null,
OrderBy =
!string.IsNullOrEmpty(odataQueryOptions.OrderBy?.RawValue)
? orderFactory.Create <T>(odataQueryOptions.OrderBy.RawValue)
.Select(
description =>
new SortDescription(
description.KeySelector,
(SortDirection)description.Direction))
.ToList()
: null,
Filter =
!string.IsNullOrEmpty(odataQueryOptions.Filter?.RawValue)
? filterFactiory.Create <T>(odataQueryOptions.Filter.RawValue)
: null
});
}
public void WhenApplyingSerializedExpressionThenCreatesSameResultAsOriginalExpressionWithNotFlagsEnumComparison()
{
Func<FakeItem, bool> original = x => x.NotFlagsValue == NotFlags.Fine && x.IntValue >= 3;
var factory = new FilterExpressionFactory(new MemberNameResolver(), Enumerable.Empty<IValueExpressionFactory>());
var deserialized = factory.Create<FakeItem>("NotFlagsValue eq Highway.Data.Tests.OData.NotFlags'Fine' And IntValue ge 3");
var originalResult = _collection.Where(original).ToArray();
var deserializedResult = _collection.Where(deserialized.Compile()).ToArray();
Assert.True(originalResult.SequenceEqual(deserializedResult));
}
public void WhenParsingInvalidExpressionThenThrows(string filter, Type exceptionType)
{
Assert.Throws(exceptionType, () => _factory.Create <FakeItem>(filter));
}
/// <summary>
/// Converts an OData formatted query into an expression.
/// </summary>
/// <param name="filter">The query to convert.</param>
/// <typeparam name="T">The parameter type.</typeparam>
/// <returns>An expression tree for the passed query.</returns>
public Expression <Func <T, bool> > Convert <T>(string filter)
{
return(_parser.Create <T>(filter));
}
public void WhenParsingInputThenCreatesExpectedExpression(string input, string expected)
{
var filterFactory = new FilterExpressionFactory(new MemberNameResolver(), Enumerable.Empty<IValueExpressionFactory>());
var expression = filterFactory.Create<TypeInstanceData>(input);
Assert.AreEqual(expected, expression.ToString());
}
