public void GetHashCode_FilterExpression_ReturnsFilterExpressionHashCode()
{
var filterExpression = FilterExpression.Binary(FilterExpression.Constant(4), FilterExpressionOperator.LessThanOrEqual, FilterExpression.MemberAccess("HelloWorld"));
var queryPart = new FilterQueryPart(filterExpression);
Assert.That(queryPart.GetHashCode(), Is.EqualTo(filterExpression.GetHashCode()));
}
public void Equals_Self_ReturnsTrue()
{
var queryPart = new FilterQueryPart(FilterExpression.Binary(FilterExpression.MemberAccess("Hello"), FilterExpressionOperator.LessThan, FilterExpression.Constant(4)));
var other = queryPart;
var actual = queryPart.Equals(other);
Assert.That(actual, Is.True);
}
public void Equals_ObjectOfDifferentType_ReturnsFalse()
{
var queryPart = new FilterQueryPart(FilterExpression.Binary(FilterExpression.MemberAccess("Hello"), FilterExpressionOperator.LessThan, FilterExpression.Constant(4)));
object other = String.Empty;
var actual = queryPart.Equals(other);
Assert.That(actual, Is.False);
}
public void Equals_FilterQueryPartNull_ReturnsFalse()
{
var queryPart = new FilterQueryPart(FilterExpression.Binary(FilterExpression.MemberAccess("Hello"), FilterExpressionOperator.LessThan, FilterExpression.Constant(4)));
FilterQueryPart other = null;
var actual = queryPart.Equals(other);
Assert.That(actual, Is.False);
}
public void Translate_EqualsFilterExpressionLeftConstant_ReturnsCorrectLinqExpression()
{
var filterExpression = FilterExpression.Binary(FilterExpression.Constant("hello"), FilterExpressionOperator.Equal, FilterExpression.MemberAccess("TestString"));
var expression = _filterExpressionTranslator.Translate(filterExpression);
var expected = GetLambdaBody(x => "hello" == x.TestString);
Assert.That(expression.ToString(), Is.EqualTo(expected.ToString()));
}
public void Translate_GreaterThanOrEqualToFilterExpression_ReturnsCorrectLinqExpression()
{
var filterExpression = FilterExpression.Binary(FilterExpression.MemberAccess("TestInt"), FilterExpressionOperator.GreaterThanOrEqual, FilterExpression.Constant(42));
var expression = _filterExpressionTranslator.Translate(filterExpression);
var expected = GetLambdaBody(x => x.TestInt >= 42);
Assert.That(expression.ToString(), Is.EqualTo(expected.ToString()));
}
public void Translate_EqualsFilterExpressionLeftDecimalRightInt_ReturnsCorrectLinqExpression()
{
var filterExpression = FilterExpression.Binary(FilterExpression.MemberAccess("TestDecimal"), FilterExpressionOperator.Equal, FilterExpression.MemberAccess("TestInt"));
var expression = _filterExpressionTranslator.Translate(filterExpression);
var expected = GetLambdaBody(x => x.TestDecimal == (decimal)x.TestInt);
Assert.That(expression.ToString(), Is.EqualTo(expected.ToString()));
}
public void Translate_EqualsFilterExpressionRightTypeAssignableFromLeftType_ReturnsCorrectLinqExpression()
{
var filterExpression = FilterExpression.Binary(FilterExpression.MemberAccess("TestString"), FilterExpressionOperator.Equal, FilterExpression.MemberAccess("TestObject"));
var expression = _filterExpressionTranslator.Translate(filterExpression);
var expected = GetLambdaBody(x => x.TestString == (string)x.TestObject);
Assert.That(expression.ToString(), Is.EqualTo(expected.ToString()));
}
public FilterExpression BuildExpression(Stack <Token> stack)
{
if (stack == null)
{
throw new ArgumentNullException("stack", "Cannot build binary expression from null expression stack.");
}
if (stack.Count < 1)
{
throw new ArgumentException("Cannot build binary expression from empty expression stack.");
}
var token = stack.Pop();
if (token == null)
{
throw new ArgumentException("Cannot parse a null token.");
}
var op = token.Value;
var binaryOperator = op.GetFromODataQueryOperatorString();
if (binaryOperator.IsBinaryOperator() == false)
{
throw new ArgumentException(String.Format("Could not create binary expression with operator '{0}'. It is not a binary operator.", binaryOperator));
}
var right = _filterExpressionParserStrategy.BuildExpression(stack);
if (right == null)
{
throw new ArgumentException("Could not create binary expression with null right side.");
}
var left = _filterExpressionParserStrategy.BuildExpression(stack);
if (left == null)
{
throw new ArgumentException("Could not create binary expression with null left side.");
}
var result = FilterExpression.Binary(left, binaryOperator, right);
return(result);
}
public void Translate_TestIntEqualsThree_ReturnsOneResult()
{
var left = FilterExpression.MemberAccess("TestInt");
var right = FilterExpression.Constant(3);
var filterExpression = FilterExpression.Binary(left, FilterExpressionOperator.Equal, right);
var query = new ODataQuery
{
FilterPredicate = ODataQueryPart.Filter(filterExpression)
};
var expression = _translator.Translate <TestModel>(query);
var fn = (Func <IQueryable <TestModel>, IQueryable <TestModel> >)expression.Compile();
var result = fn(_source).ToList();
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result[0].TestInt, Is.EqualTo(3));
}
public void FilterQueryPart_InheritsFromIEquatable()
{
var actual = new FilterQueryPart(FilterExpression.Binary(FilterExpression.MemberAccess("Hello"), FilterExpressionOperator.LessThan, FilterExpression.Constant(4)));
Assert.That(actual, Is.InstanceOf <IEquatable <FilterQueryPart> >());
}
public void Translate_UnaryFilterExpression_ReturnsCorrectLinqExpression()
{
var filterExpression = FilterExpression.Unary(FilterExpressionOperator.Not, FilterExpression.Binary(FilterExpression.MemberAccess("TestString"), FilterExpressionOperator.Equal, FilterExpression.Constant("hi")));
var expression = _filterExpressionTranslator.Translate(filterExpression);
var expected = GetLambdaBody(x => !(x.TestString == "hi"));
Assert.That(expression.ToString(), Is.EqualTo(expected.ToString()));
}
