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); }