public void Assert_Nullable_Float_Collection_Inequality_Expression_With_Array_Value_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableFloatCollection), randomHydra.NullableFloatCollection.ToArray(), ExpressionOperator.NotEqual)); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => !t.NullableFloatCollection.SequenceEqual(randomHydra.NullableFloatCollection)); Assert.DoesNotContain(result, t => t.NullableFloatCollection.SequenceEqual(randomHydra.NullableFloatCollection)); }
public void Assert_Nullable_Float_Collection_Contains_Single_Value_Dynamic_Query_Expression_Is_Generated_Correctly() { // Arrange var randomFloat = Utilities.GetRandomItem(HydraArmy.Select(t => t.NullableFloatCollection)).FirstOrDefault(); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableFloatCollection), randomFloat, ExpressionOperator.Contains)); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.NullableFloatCollection.Contains(randomFloat)); Assert.DoesNotContain(result, t => !t.NullableFloatCollection.Contains(randomFloat)); }
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) == false); }
public void Assert_Nullable_Integer_Less_Than_Or_Equal_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy.Where(t => t.NullableInteger.HasValue)); var expression = ExpressionBuilder.CreateBinary <Hydra>(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_DateTime_Greater_Than_Or_Equal_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinary <Hydra>(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_DateTime_Collection_Inequality_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.DateTimeCollection), randomHydra.DateTimeCollection, ExpressionOperator.NotEqual); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.DateTimeCollection.SequenceEqual(randomHydra.DateTimeCollection) == false); Assert.DoesNotContain(result, t => t.DateTimeCollection.SequenceEqual(randomHydra.DateTimeCollection)); }
public void Assert_Boolean_Array_Contains_Single_Value_Dynamic_Query_Expression_Is_Generated_Correctly() { // Arrange var randomBoolean = Utilities.GetRandomItem(HydraArmy.Select(t => t.BooleanArray)).FirstOrDefault(); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.BooleanArray), randomBoolean, ExpressionOperator.Contains)); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.BooleanArray.Contains(randomBoolean)); Assert.DoesNotContain(result, t => t.BooleanArray.Contains(randomBoolean) == false); }
public void Assert_Nullable_Char_Contains_On_Value_Dynamic_Query_Expression_Is_Generated_Correctly() { // Arrange var randomChars = Utilities.GetRandomItems(HydraArmy.Select(t => t.NullableChar)); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableChar), randomChars, ExpressionOperator.ContainsOnValue)); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => randomChars.Contains(t.NullableChar)); Assert.DoesNotContain(result, t => randomChars.Contains(t.NullableChar) == false); }
public void Assert_TimeSpan_Array_Equality_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.TimeSpanArray), randomHydra.TimeSpanArray, 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)); }
public void Assert_TimeSpan_Less_Than_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.TimeSpan), randomHydra.TimeSpan, ExpressionOperator.LessThan); // 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_TimeSpan_Contains_On_Value_Expression_Is_Generated_Correctly() { // Arrange var randomTimeSpans = Utilities.GetRandomItems(HydraArmy.Select(t => t.TimeSpan)); var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.TimeSpan), randomTimeSpans, ExpressionOperator.ContainsOnValue); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => randomTimeSpans.Contains(t.TimeSpan)); Assert.DoesNotContain(result, t => !randomTimeSpans.Contains(t.TimeSpan)); }
public void Assert_Nullable_DateTime_Greater_Than_Dynamic_Query_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy.Where(t => t.NullableDateTime.HasValue)); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableDateTime), randomHydra.NullableDateTime, ExpressionOperator.GreaterThan)); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.NullableDateTime > randomHydra.NullableDateTime); Assert.DoesNotContain(result, t => t.NullableDateTime <= randomHydra.NullableDateTime); }
public void Assert_Integer_Inequality_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.Integer), randomHydra.Integer, ExpressionOperator.NotEqual); // 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_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_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_Float_Less_Than_Or_Equal_Dynamic_Query_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy.Where(t => t.NullableFloat.HasValue)); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableFloat), randomHydra.NullableFloat, ExpressionOperator.LessThanOrEqual)); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.NullableFloat <= randomHydra.NullableFloat); Assert.DoesNotContain(result, t => t.NullableFloat > randomHydra.NullableFloat); }
public void Assert_Integer_Less_Than_Dynamic_Query_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.Integer), randomHydra.Integer, ExpressionOperator.LessThan)); // 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_Nullable_Char_Array_Equality_Dynamic_Query_Expression_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinaryFromQuery <Hydra>(BuildQueryText(nameof(Hydra.NullableCharArray), randomHydra.NullableCharArray, ExpressionOperator.Equal)); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.NullableCharArray.SequenceEqual(randomHydra.NullableCharArray)); Assert.DoesNotContain(result, t => t.NullableCharArray.SequenceEqual(randomHydra.NullableCharArray) == false); }
public void Assert_Nullable_Integer_Array_Inequality_Expression_With_List_Value_Is_Generated_Correctly() { // Arrange var randomHydra = Utilities.GetRandomItem(HydraArmy); var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.NullableIntegerArray), randomHydra.NullableIntegerArray.ToList(), ExpressionOperator.NotEqual); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.NullableIntegerArray.SequenceEqual(randomHydra.NullableIntegerArray) == false); Assert.DoesNotContain(result, t => t.NullableIntegerArray.SequenceEqual(randomHydra.NullableIntegerArray)); }
public void Assert_DateTime_Array_Contains_Single_Value_Expression_Is_Generated_Correctly() { // Arrange var randomDateTime = Utilities.GetRandomItem(HydraArmy.Select(t => t.DateTimeArray)).FirstOrDefault(); var expression = ExpressionBuilder.CreateBinary <Hydra>(nameof(Hydra.DateTimeArray), randomDateTime, ExpressionOperator.Contains); // Act var result = HydraArmy.Where(expression.Compile()).ToList(); // Assert Assert.NotEmpty(result); Assert.Contains(result, t => t.DateTimeArray.Contains(randomDateTime)); Assert.DoesNotContain(result, t => t.DateTimeArray.Contains(randomDateTime) == false); }
public void Assert_Nullable_Integer_Collection_Contains_Single_Value_Expression_Is_Generated_Correctly() { // Arrange var randomInteger = Utilities.GetRandomItem(HydraArmy.Select(t => t.NullableIntegerCollection)).FirstOrDefault(); var expression = ExpressionBuilder.CreateBinary <Hydra>(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_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) == false); }
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); }