public void Assert_Char_Contains_On_Value_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomChars = Utilities.GetRandomItems(HydraArmy.Select(t => t.Char));
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.Char), randomChars, ExpressionOperator.ContainsOnValue));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => randomChars.Contains(t.Char));
Assert.DoesNotContain(result, t => randomChars.Contains(t.Char) == false);
}
public void Assert_Char_Array_Equality_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.CharArray), randomHydra.CharArray, ExpressionOperator.Equal));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.CharArray.SequenceEqual(randomHydra.CharArray));
Assert.DoesNotContain(result, t => t.CharArray.SequenceEqual(randomHydra.CharArray) == false);
}
public void Assert_Nullable_TimeSpan_Greater_Than_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy.Where(t => t.NullableTimeSpan.HasValue));
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.NullableTimeSpan), randomHydra.NullableTimeSpan, ExpressionOperator.GreaterThan);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.NullableTimeSpan > randomHydra.NullableTimeSpan);
Assert.DoesNotContain(result, t => t.NullableTimeSpan <= randomHydra.NullableTimeSpan);
}
public void Assert_Nullable_Float_Inequality_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableFloat), randomHydra.NullableFloat, ExpressionOperator.NotEqual));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => Math.Abs(t.NullableFloat.GetValueOrDefault() - randomHydra.NullableFloat.GetValueOrDefault()) > 0.01);
Assert.DoesNotContain(result, t => Math.Abs(t.NullableFloat.GetValueOrDefault() - randomHydra.NullableFloat.GetValueOrDefault()) < 0.01);
}
public void Assert_String_Collection_Inequality_Expression_With_Array_Value_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.StringCollection), randomHydra.StringCollection.ToArray(), ExpressionOperator.NotEqual);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => !t.StringCollection.SequenceEqual(randomHydra.StringCollection));
Assert.DoesNotContain(result, t => t.StringCollection.SequenceEqual(randomHydra.StringCollection));
}
public void Assert_String_Inequality_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.FullName), randomHydra.FullName, ExpressionOperator.NotEqual);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.FullName != randomHydra.FullName);
Assert.DoesNotContain(result, t => t.FullName == randomHydra.FullName);
}
public void Assert_Float_Less_Than_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.Float), randomHydra.Float, ExpressionOperator.LessThan));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.Float < randomHydra.Float);
Assert.DoesNotContain(result, t => t.Float >= randomHydra.Float);
}
public void Assert_Nullable_Integer_Less_Than_Or_Equal_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy.Where(t => t.NullableInteger.HasValue));
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableInteger), randomHydra.NullableInteger, ExpressionOperator.LessThanOrEqual));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.NullableInteger <= randomHydra.NullableInteger);
Assert.DoesNotContain(result, t => t.NullableInteger > randomHydra.NullableInteger);
}
public void Assert_String_Ends_With_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.FullName), randomHydra.LastName, ExpressionOperator.EndsWith));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.FullName.EndsWith(randomHydra.LastName));
Assert.DoesNotContain(result, t => !t.FullName.EndsWith(randomHydra.LastName));
}
public void Assert_Float_Array_Contains_Single_Value_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomFloat = Utilities.GetRandomItem(HydraArmy.Select(t => t.FloatArray)).FirstOrDefault();
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.FloatArray), randomFloat, ExpressionOperator.Contains));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.FloatArray.Contains(randomFloat));
Assert.DoesNotContain(result, t => !t.FloatArray.Contains(randomFloat));
}
public void Assert_String_Contains_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomString = Utilities.GetRandomItem(HydraArmy.Select(t => string.Concat(t.FirstName, " ")));
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.FullName), randomString, ExpressionOperator.Contains));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => randomString.Contains(t.FirstName));
Assert.DoesNotContain(result, t => !randomString.Contains(t.FirstName));
}
public void Assert_DateTime_Greater_Than_Or_Equal_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.DateTime), randomHydra.DateTime, ExpressionOperator.GreaterThanOrEqual));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.DateTime >= randomHydra.DateTime);
Assert.DoesNotContain(result, t => t.DateTime < randomHydra.DateTime);
}
public void Assert_Boolean_Inequality_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.Boolean), randomHydra.Boolean, ExpressionOperator.NotEqual));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.Boolean != randomHydra.Boolean);
Assert.DoesNotContain(result, t => t.Boolean == randomHydra.Boolean);
}
public void Assert_Nullable_Integer_Collection_Equality_Expression_With_Array_Value_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableIntegerCollection), randomHydra.NullableIntegerCollection.ToArray(), ExpressionOperator.Equal));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.NullableIntegerCollection.SequenceEqual(randomHydra.NullableIntegerCollection));
Assert.DoesNotContain(result, t => t.NullableIntegerCollection.SequenceEqual(randomHydra.NullableIntegerCollection) == false);
}
public void Assert_TimeSpan_Array_Equality_Expression_With_List_Value_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.TimeSpanArray), randomHydra.TimeSpanArray.ToList(), ExpressionOperator.Equal);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.TimeSpanArray.SequenceEqual(randomHydra.TimeSpanArray));
Assert.DoesNotContain(result, t => t.TimeSpanArray.SequenceEqual(randomHydra.TimeSpanArray) == false);
}
public void Assert_Nullable_Integer_Collection_Contains_Single_Value_Dynamic_Query_Expression_Is_Generated_Correctly()
{
// Arrange
var randomInteger = Utilities.GetRandomItem(HydraArmy.Select(t => t.NullableIntegerCollection)).FirstOrDefault();
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableIntegerCollection), randomInteger, ExpressionOperator.Contains));
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.NullableIntegerCollection.Contains(randomInteger));
Assert.DoesNotContain(result, t => t.NullableIntegerCollection.Contains(randomInteger) == false);
}
public void Assert_TimeSpan_Less_Than_Or_Equal_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.TimeSpan), randomHydra.TimeSpan, ExpressionOperator.LessThanOrEqual);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.TimeSpan <= randomHydra.TimeSpan);
Assert.DoesNotContain(result, t => t.TimeSpan > randomHydra.TimeSpan);
}
public void Assert_String_Contains_On_Value_Expression_Is_Generated_Correctly()
{
// Arrange
var randomStrings = Utilities.GetRandomItems(HydraArmy.Select(t => t.FullName));
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.FullName), randomStrings, ExpressionOperator.ContainsOnValue);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => randomStrings.Contains(t.FullName));
Assert.DoesNotContain(result, t => !randomStrings.Contains(t.FullName));
}
public void Assert_Nullable_Boolean_Array_Contains_Single_Value_Expression_Is_Generated_Correctly()
{
// Arrange
var randomBoolean = Utilities.GetRandomItem(HydraArmy.Select(t => t.NullableBooleanArray)).FirstOrDefault();
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.NullableBooleanArray), randomBoolean, ExpressionOperator.Contains);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.NullableBooleanArray.Contains(randomBoolean));
Assert.DoesNotContain(result, t => t.NullableBooleanArray.Contains(randomBoolean) == false);
}
public void Assert_String_Collection_Contains_Single_Value_Expression_Is_Generated_Correctly()
{
// Arrange
var randomString = Utilities.GetRandomItem(HydraArmy.Select(t => t.StringCollection)).FirstOrDefault();
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.StringCollection), randomString, ExpressionOperator.Contains);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.StringCollection.Contains(randomString));
Assert.DoesNotContain(result, t => !t.StringCollection.Contains(randomString));
}
public void Assert_Nullable_Boolean_Collection_Inequality_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.NullableBooleanCollection), randomHydra.NullableBooleanCollection, ExpressionOperator.NotEqual);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.NullableBooleanCollection.SequenceEqual(randomHydra.NullableBooleanCollection) == false);
Assert.DoesNotContain(result, t => t.NullableBooleanCollection.SequenceEqual(randomHydra.NullableBooleanCollection));
}
public void Assert_Integer_Greater_Than_Expression_Is_Generated_Correctly()
{
// Arrange
var randomHydra = Utilities.GetRandomItem(HydraArmy);
var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.Integer), randomHydra.Integer, ExpressionOperator.GreaterThan);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.Integer > randomHydra.Integer);
Assert.DoesNotContain(result, t => t.Integer <= randomHydra.Integer);
}
public void Assert_Or_Composition_Gives_Correct_Result()
{
// Arrange
var randomHydra1 = Utilities.GetRandomItem(HydraArmy);
var randomHydra2 = Utilities.GetRandomItem(HydraArmy);
var queryText = ComposeQuery(BuildQueryText(nameof(Hydra.FullName), randomHydra1.FullName, ExpressionOperator.Equal), BuildQueryText(nameof(Hydra.DateTime), randomHydra2.DateTime, ExpressionOperator.Equal), ExpressionCompose.Or);
var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(queryText);
// Act
var result = HydraArmy.Where(expression.Compile()).ToList();
// Assert
Assert.NotEmpty(result);
Assert.Contains(result, t => t.FullName == randomHydra1.FullName || t.DateTime == randomHydra2.DateTime);
Assert.DoesNotContain(result, t => t.FullName != randomHydra1.FullName && t.DateTime != randomHydra2.DateTime);
}
