public void ParseQueryOptionsShouldHandleOperationShortCodes()
{
var validOptions = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = "123",
PropertyName = "name",
Operator = FilterOperation.Equals
},
new Filter
{
Value = "21",
PropertyName = "age",
Operator = FilterOperation.GreaterThanOrEqual
}
}
};
DynamicQueryOptions result = ExpressionBuilder.ParseQueryOptions("o=eq&p=name&v=123&o=gtoe&p=age&v=21");
Assert.True(AreObjectPropertiesMatching(validOptions, result));
}
public void ParseQueryOptionsShouldParseMultipleLevelMemberQueriesWithPrimitiveTypes()
{
string innerMemberQuery = $"o=Any&p=InnerPrimitiveList&v=(o=eq&p=_&v=3)";
var validOptions = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Operator = FilterOperation.Equals,
PropertyName = "_",
Value = "3"
}
}
},
PropertyName = nameof(TestModel.InnerPrimitiveList),
Operator = FilterOperation.Any
}
}
};
DynamicQueryOptions result = ExpressionBuilder.ParseQueryOptions(innerMemberQuery);
Assert.True(AreObjectPropertiesMatching(validOptions, result));
}
public void ParseQueryOptionsShouldHandleLogicalOperators()
{
DynamicQueryOptions expectedResult = new DynamicQueryOptions
{
Filters = new List <Filter>()
{
new Filter
{
LogicalOperator = LogicalOperator.OrElse,
Operator = FilterOperation.Equals,
PropertyName = "Fizz",
Value = "Buzz"
},
new Filter
{
LogicalOperator = LogicalOperator.AndAlso,
Operator = FilterOperation.Equals,
PropertyName = "Fizz",
Value = "NotBuzz"
}
}
};
DynamicQueryOptions result =
ExpressionBuilder.ParseQueryOptions("o=eq|orelse&p=Fizz&v=Buzz&o=eq&p=Fizz&v=NotBuzz");
Assert.NotNull(result.Filters);
Assert.NotEmpty(result.Filters);
Assert.Equal(result.Filters[0].ToHTTPQueryString(), expectedResult.Filters[0].ToHTTPQueryString());
Assert.Equal(result.Filters[1].ToHTTPQueryString(), expectedResult.Filters[1].ToHTTPQueryString());
}
public void ShouldPopulateWithLogicalOperators()
{
var opts = new DynamicQueryOptions();
ExpressionBuilder.PopulateDynamicQueryOptions(opts,
operations: new string[]
{
$"{FilterOperation.Equals}|{LogicalOperator.OrElse}",
$"{FilterOperation.Equals}"
},
parameterNames: _validParameterNames,
parameterValues: _validParameterValues,
sortOptions: _emptyArray,
offsetOptions: _emptyArray,
countOptions: _emptyArray);
Assert.NotNull(opts.Filters);
Assert.NotEmpty(opts.Filters);
Assert.Equal(FilterOperation.Equals, opts.Filters[0].Operator);
Assert.Equal(LogicalOperator.OrElse, opts.Filters[0].LogicalOperator);
Assert.Equal(_validParameterNames[0], opts.Filters[0].PropertyName);
Assert.Equal(_validParameterValues[0], opts.Filters[0].Value);
Assert.Equal(FilterOperation.Equals, opts.Filters[1].Operator);
Assert.Equal(LogicalOperator.AndAlso, opts.Filters[1].LogicalOperator);
Assert.Equal(_validParameterNames[1], opts.Filters[1].PropertyName);
Assert.Equal(_validParameterValues[1], opts.Filters[1].Value);
}
public void ApplyFiltersShouldHandleEnums(Months month, FilterOperation filterOperation, List <Months> expectedMonths)
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var filters = new DynamicQueryOptions
{
Filters =
{
new Filter
{
Value = month.ToString(),
PropertyName = "Month",
Operator = filterOperation,
LogicalOperator = LogicalOperator.AndAlso
}
}
};
List <TestModel> result = currentSet.ApplyFilters(filters).ToList();
Assert.Equal(expectedMonths.Count(), result.Count());
foreach (Months resultMonth in result.Select(x => x.Month))
{
Assert.Contains(expectedMonths, m => m == resultMonth);
}
}
public void ApplyFiltersShouldAppendGivenFiltersToTheGivenSet()
{
IQueryable <TestModel> currentSet = CreateSampleSet();
var filters = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = "10",
PropertyName = "Age",
Operator = FilterOperation.Equals
},
new Filter
{
Value = "testOne",
PropertyName = "Name",
Operator = FilterOperation.StartsWith,
CaseSensitive = true
}
}
};
IQueryable <TestModel> returnedSet = currentSet.ApplyFilters(filters).AsQueryable();
string paramName = nameof(TestModel).ToLower();
string expectedQuery = $"{paramName} => (({paramName}.Age == 10) AndAlso {paramName}.Name.ToLowerInvariant().StartsWith(\"testone\"))";
var expressionMethodCall = returnedSet.Expression as MethodCallExpression;
Assert.NotNull(expressionMethodCall);
/* First member of the MethodCallExpression.Arguments is always the type that the expression was written for
* and the second parameter is the actual expression string.
*/
Assert.Equal(expectedQuery, ((MethodCallExpression)expressionMethodCall.Arguments[0]).Arguments[1].ToString());
}
public void InvalidOperationRequestedShouldThrowOperationNotSupportedException()
{
var opts = new DynamicQueryOptions();
Assert.Throws <OperationNotSupportedException>(() => ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _arrayOfOne, _arrayOfOne, _arrayOfOne, _arrayOfOne, _arrayOfOne, _arrayOfOne));
}
public void ParseQueryOptionsShouldHandleOperationCustomShortCodes()
{
var validOptions = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = "123",
PropertyName = "name",
Operator = FilterOperation.Equals
},
new Filter
{
Value = "21",
PropertyName = "age",
Operator = FilterOperation.GreaterThanOrEqual
}
}
};
var customOpShortCodes = new CustomOpCodes
{
{ "fizz", FilterOperation.Equals },
{ "buzz", FilterOperation.GreaterThanOrEqual }
};
DynamicQueryOptions result = ExpressionBuilder.ParseQueryOptions("o=fizz&p=name&v=123&o=buzz&p=age&v=21", opShortCodes: customOpShortCodes);
Assert.True(AreObjectPropertiesMatching(validOptions, result));
}
public void ShouldSetGivenAssignDataSetCountWhenOptionsNotNull()
{
bool changedIncludeDataSetCount = !_defaultIncludeDataSetCount;
var parameterlessInstance = new DynamicQueryAttribute(includeDataSetCountToPagination: changedIncludeDataSetCount);
DynamicQueryOptions executedOptions = ExecuteAction(parameterlessInstance);
Assert.Equal(executedOptions.PaginationOption.AssignDataSetCount, changedIncludeDataSetCount);
}
public void ShouldSetOffsetToZeroWhenLessThanZero()
{
var attributeInstance = new DynamicQueryAttribute();
string queryWithOffsetNegative = DYNAMIC_QUERY_STRING.Replace("offset=0", "offset=-1");
DynamicQueryOptions executedOptionsOffsetNegative = ExecuteAction(attributeInstance, queryWithOffsetNegative);
Assert.Equal(0, executedOptionsOffsetNegative.PaginationOption.Offset);
}
public void ParseQueryOptionsShouldReturnEmptyOptionsWhenQueryIsNullOrEmpty()
{
var emptyDynamicQueryOptions = new DynamicQueryOptions();
DynamicQueryOptions resultForNull = ExpressionBuilder.ParseQueryOptions(null);
DynamicQueryOptions resultForEmpty = ExpressionBuilder.ParseQueryOptions(string.Empty);
Assert.True(AreObjectPropertiesMatching(emptyDynamicQueryOptions, resultForNull));
Assert.True(AreObjectPropertiesMatching(emptyDynamicQueryOptions, resultForEmpty));
}
public void ShouldParseDataSetCountWhenIncludeDataSetCountAssignedAndThereIsNoPaginationOption()
{
var attributeInstance = new DynamicQueryAttribute();
string queryWithOffsetNegative = DYNAMIC_QUERY_STRING.Replace("offset=0", string.Empty).Replace("count=10", string.Empty);
DynamicQueryOptions executedOptionsOffsetNegative = ExecuteAction(attributeInstance, queryWithOffsetNegative);
Assert.NotNull(executedOptionsOffsetNegative.PaginationOption);
Assert.True(executedOptionsOffsetNegative.PaginationOption.AssignDataSetCount);
}
public void InvalidSortOptionDirectionShouldThrowInvalidQueryException()
{
var opts = new DynamicQueryOptions();
Assert.Throws <InvalidDynamicQueryException>(() =>
{
ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _validOperations, _validParameterNames, _validParameterValues, new string[] { "Names,Invalid" }, _arrayOfOne, _arrayOfOne);
});
}
public void ShouldSetCountToOneWhenRequestedCountLessThanOrEqualToZero()
{
var attributeInstance = new DynamicQueryAttribute();
string queryWithCountZero = DYNAMIC_QUERY_STRING.Replace("count=10", "count=0");
string queryWithCountNegative = DYNAMIC_QUERY_STRING.Replace("count=10", "count=-1");
DynamicQueryOptions executedOptionsWithCountZero = ExecuteAction(attributeInstance, queryWithCountZero);
DynamicQueryOptions executedOptionsWithCountNegative = ExecuteAction(attributeInstance, queryWithCountNegative);
Assert.Equal(1, executedOptionsWithCountZero.PaginationOption.Count);
Assert.Equal(1, executedOptionsWithCountNegative.PaginationOption.Count);
}
public void CaseSensitivityShouldWork()
{
var queryable = _ctx.Users.AsQueryable();
var withResultFilterWithCSEnabled = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
CaseSensitive = true,
Operator = FilterOperation.Equals,
PropertyName = "Name",
Value = "test_1"
}
},
IgnorePredefinedOrders = true
};
var withResultFilterWithCSDisabled = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Operator = FilterOperation.Equals,
PropertyName = "Name",
Value = "Test_1"
}
},
IgnorePredefinedOrders = true
};
var noResultFilterWithCSDisabledAndInvalidCase = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{ // Default value of CS is false
Operator = FilterOperation.Equals,
PropertyName = "Name",
Value = "test_1"
}
},
IgnorePredefinedOrders = true
};
var resultOfwithResultFilterWithCSEnabled = queryable.ApplyFilters(withResultFilterWithCSEnabled).ToList();
var resultOfwithResultFilterWithCSDisabled = queryable.ApplyFilters(withResultFilterWithCSDisabled).ToList();
var resultOfnoResultFilterWithCSDisabledAndInvalidCase = queryable.ApplyFilters(noResultFilterWithCSDisabledAndInvalidCase).ToList();
Assert.NotEmpty(resultOfwithResultFilterWithCSEnabled);
Assert.NotEmpty(resultOfwithResultFilterWithCSDisabled);
Assert.Empty(resultOfnoResultFilterWithCSDisabledAndInvalidCase);
}
public void ParseQueryOptionsShouldNotClearSpacesInValueParameterValue()
{
const string finalParameterValue = "Movies and Music";
string valueWithSpace = string.Concat(dynamicQueryWithParam.Replace("dqb=", string.Empty), "%20and%20Music");
DynamicQueryOptions result = ExpressionBuilder.ParseQueryOptions(valueWithSpace);
Assert.NotNull(result.Filters);
Assert.NotEmpty(result.Filters);
Assert.Equal(result.Filters[0].Value, finalParameterValue);
}
public void ValidSortingOptionsShouldParseAllMembers()
{
var opts = new DynamicQueryOptions();
ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _validOperations, _validParameterNames, _validParameterValues, new string[] { "Name,Desc", "Age,Asc" }, _emptyArray, _emptyArray);
Assert.Equal("Name", opts.SortOptions[0].PropertyName);
Assert.Equal(SortingDirection.Desc, opts.SortOptions[0].SortingDirection);
Assert.Equal("Age", opts.SortOptions[1].PropertyName);
Assert.Equal(SortingDirection.Asc, opts.SortOptions[1].SortingDirection);
}
public void OnActionExecutingShouldModifyDynamicQueryOptionsActionParameterWhenItsPresent()
{
ActionExecutingContext actionContext = CreateContext();
DynamicQueryOptions expectedResult = ExpressionBuilder.ParseQueryOptions(DYNAMIC_QUERY_STRING);
new DynamicQueryAttribute().OnActionExecuting(actionContext);
var result = actionContext.ActionArguments[nameof(DynamicQueryOptions)] as DynamicQueryOptions;
Assert.True(AreObjectPropertiesMatching(expectedResult, result));
}
public void ShouldSetCountToMaxWhenCountExceedsAndOptionsWereSetToGetMaxOrDefault()
{
var behaviourSetInstance = new DynamicQueryAttribute(exceededPaginationCountBehaviour: PaginationBehaviour.GetMax);
var defaultBehaviourInstance = new DynamicQueryAttribute();
string queryExceedingMaxCount = DYNAMIC_QUERY_STRING.Replace("count=10", $"count={_defaultMaxCountSize + 1}");
DynamicQueryOptions executedOptionsWithSetOptions = ExecuteAction(behaviourSetInstance, queryExceedingMaxCount);
DynamicQueryOptions executedOptionsWithDefaultOptions = ExecuteAction(defaultBehaviourInstance, queryExceedingMaxCount);
Assert.Equal(executedOptionsWithSetOptions.PaginationOption.Count, _defaultMaxCountSize);
Assert.Equal(executedOptionsWithDefaultOptions.PaginationOption.Count, _defaultMaxCountSize);
}
public void NullOrEmptySortOptions()
{
var opts = new DynamicQueryOptions();
List <SortOption> currentSortOptsValue = opts.SortOptions;
ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _validOperations, _validParameterNames, _validParameterValues, null, _emptyArray, _emptyArray);
Assert.Equal(currentSortOptsValue, opts.SortOptions);
ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _validOperations, _validParameterNames, _validParameterValues, _arrayOfOne, _emptyArray, _emptyArray);
Assert.Equal(currentSortOptsValue, opts.SortOptions);
}
public void ValidQueryShouldFillFilterAndSortingOptions()
{
var optsWithSorting = new DynamicQueryOptions();
var optsWithoutSorting = new DynamicQueryOptions();
ExpressionBuilder.PopulateDynamicQueryOptions(
optsWithoutSorting, _validOperations, _validParameterNames, _validParameterValues, null, _emptyArray, _emptyArray);
ExpressionBuilder.PopulateDynamicQueryOptions(
optsWithSorting, _validOperations, _validParameterNames, _validParameterValues, _validSortOptions, _emptyArray, _emptyArray);
Assert.True(AreObjectPropertiesMatching(optsWithoutSorting, _reflectedObjectWithValidParameters));
Assert.True(AreObjectPropertiesMatching(optsWithSorting, _reflectedObjectWithValidParametersAndSorted));
}
public void ParseQueryOptionsShouldParseMultipleLevelMemberQueries()
{
const string firstLevelInnerCollectionMemberKey = "FirstLevelInnerCollectionMember";
const string secondLevelInnerCollectionMemberKey = "SecondLevelInnerCollectionMember";
const string secondLevelInnerMemberProperty = "SecondLevelInnerMemberProperty";
const string secondLevelInnerMemberQueryValue = "3";
string innerMemberQuery = $"o=Any&p={firstLevelInnerCollectionMemberKey}&v=(o=All&p={secondLevelInnerCollectionMemberKey}&v=(o=Equals&p={secondLevelInnerMemberProperty}&v={secondLevelInnerMemberQueryValue}))";
var validOptions = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Operator = FilterOperation.All,
PropertyName = secondLevelInnerCollectionMemberKey,
Value = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Operator = FilterOperation.Equals,
PropertyName = secondLevelInnerMemberProperty,
Value = secondLevelInnerMemberQueryValue
}
}
}
}
}
},
PropertyName = firstLevelInnerCollectionMemberKey,
Operator = FilterOperation.Any
}
}
};
DynamicQueryOptions result = ExpressionBuilder.ParseQueryOptions(innerMemberQuery);
Assert.True(AreObjectPropertiesMatching(validOptions, result));
}
public void ApplyFiltersShouldEncapsulateUnhandledExceptionsWithItsOwnType()
{
var mockFilterList = new Mock <IList <Filter> >();
mockFilterList.Setup(x => x.Count).Returns(1);
var mockOptions = new DynamicQueryOptions
{
Filters = mockFilterList.Object.ToList()
};
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var thrownException = Assert.Throws <DynamicQueryException>(() => { currentSet.ApplyFilters(mockOptions); });
Assert.Equal(typeof(NullReferenceException), thrownException.InnerException.GetType());
}
public void NullDynamicQueryOptionsAndPropertyCountsMismatchShouldThrowDynamicQueryException()
{
var opts = new DynamicQueryOptions();
Assert.Throws <DynamicQueryException>(() => ExpressionBuilder.PopulateDynamicQueryOptions(
null, _arrayOfOne, _arrayOfOne, _arrayOfOne, _arrayOfOne, _emptyArray, _emptyArray));
Assert.Throws <QueryTripletsMismatchException>(() => ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _arrayOfTwo, _arrayOfOne, _arrayOfOne, _arrayOfOne, _emptyArray, _emptyArray));
Assert.Throws <QueryTripletsMismatchException>(() => ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _arrayOfOne, _arrayOfTwo, _arrayOfOne, _arrayOfOne, _emptyArray, _emptyArray));
Assert.Throws <QueryTripletsMismatchException>(() => ExpressionBuilder.PopulateDynamicQueryOptions(
opts, _arrayOfOne, _arrayOfOne, _arrayOfTwo, _arrayOfOne, _emptyArray, _emptyArray));
}
public void ApplyFiltersShouldPaginateWhenPaginationOptionsIsPresent()
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var optionsWithPagination = new DynamicQueryOptions
{
PaginationOption = new PaginationOption
{
Count = 1,
Offset = 1
}
};
IQueryable <TestModel> result = currentSet.ApplyFilters(optionsWithPagination);
Assert.Equal(result.Count(), optionsWithPagination.PaginationOption.Count);
Assert.Equal(result.ElementAt(0), currentSet.ElementAt(1));
}
public void Apply_filters_should_append_sorting_options_to_the_given_query()
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var ascendingSortingOptions = new DynamicQueryOptions();
ascendingSortingOptions.SortOptions.Add(new SortOption
{
PropertyName = "Age",
SortingDirection = SortingDirection.Asc
});
var descendingSortingOptions = new DynamicQueryOptions();
descendingSortingOptions.SortOptions.Add(new SortOption
{
PropertyName = "Age",
SortingDirection = SortingDirection.Desc
});
var directionNotSpecifiedSortingOptions = new DynamicQueryOptions();
directionNotSpecifiedSortingOptions.SortOptions.Add(new SortOption {
PropertyName = "Age"
});
// Unfortunately, there is no better way to check the sorting method here that i could find.
IQueryable <TestModel> resultOfAscendingOption = currentSet.ApplyFilters(ascendingSortingOptions);
Assert.Equal(resultOfAscendingOption.ElementAt(0).Age, currentSet.ElementAt(0).Age);
Assert.Equal(resultOfAscendingOption.ElementAt(1).Age, currentSet.ElementAt(2).Age);
Assert.Equal(resultOfAscendingOption.ElementAt(2).Age, currentSet.ElementAt(1).Age);
IQueryable <TestModel> resultOfDescendingOption = currentSet.ApplyFilters(descendingSortingOptions);
Assert.Equal(resultOfDescendingOption.ElementAt(0).Age, currentSet.ElementAt(1).Age);
Assert.Equal(resultOfDescendingOption.ElementAt(1).Age, currentSet.ElementAt(2).Age);
Assert.Equal(resultOfDescendingOption.ElementAt(2).Age, currentSet.ElementAt(0).Age);
IQueryable <TestModel> resultOfDirectionNotSpecified = currentSet.ApplyFilters(directionNotSpecifiedSortingOptions);
Assert.Equal(resultOfDirectionNotSpecified.ElementAt(0).Age, currentSet.ElementAt(0).Age);
Assert.Equal(resultOfDirectionNotSpecified.ElementAt(1).Age, currentSet.ElementAt(2).Age);
Assert.Equal(resultOfDirectionNotSpecified.ElementAt(2).Age, currentSet.ElementAt(1).Age);
}
public PopulateDynamicQueryOptionsTests()
{
Array.Fill(_arrayOfOne, string.Empty);
Array.Fill(_arrayOfTwo, string.Empty);
_validOperations = new string[] { "Equals", "Contains" };
_validParameterNames = new string[] { "Name", "Name" };
_validParameterValues = new string[] { "Test", "Te" };
_validSortOptions = new string[] { "Name,desc" };
string[] validSortOptionsSplitted = _validSortOptions[0].Split(',');
var validListOfOperationsParsed = new List <Filter>
{
new Filter
{
Value = _validParameterValues[0],
PropertyName = _validParameterNames[0],
Operator = (FilterOperation)Enum.Parse(typeof(FilterOperation), _validOperations[0])
},
new Filter
{
Value = _validParameterValues[1],
PropertyName = _validParameterNames[1],
Operator = (FilterOperation)Enum.Parse(typeof(FilterOperation), _validOperations[1], true)
}
};
_reflectedObjectWithValidParameters = new DynamicQueryOptions
{
Filters = validListOfOperationsParsed
};
_reflectedObjectWithValidParametersAndSorted = new DynamicQueryOptions
{
Filters = validListOfOperationsParsed
};
_reflectedObjectWithValidParametersAndSorted.SortOptions.Add(new SortOption
{
PropertyName = validSortOptionsSplitted[0],
SortingDirection = (SortingDirection)Enum.Parse(typeof(SortingDirection), validSortOptionsSplitted[1], true)
});
}
public void ApplyFiltersShouldHandleComparisonsDifferentlyForStrings()
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var caseSensitiveFilters = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = "testSix",
PropertyName = nameof(TestModel.Name),
Operator = FilterOperation.GreaterThan,
CaseSensitive = true
}
}
};
List <TestModel> result = currentSet.ApplyFilters(caseSensitiveFilters).ToList();
Assert.NotEmpty(result);
Assert.Equal(currentSet.ElementAtOrDefault(1), result[0]);
Assert.Equal(currentSet.ElementAtOrDefault(2), result[1]);
var caseInsensitiveFilters = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = "testSix",
PropertyName = nameof(TestModel.Name),
Operator = FilterOperation.GreaterThan,
CaseSensitive = false
}
}
};
result = currentSet.ApplyFilters(caseInsensitiveFilters).ToList();
Assert.NotEmpty(result);
Assert.Equal(currentSet.ElementAtOrDefault(1), result[0]);
Assert.Equal(currentSet.ElementAtOrDefault(2), result[1]);
}
public void ApplyFiltersShouldHandlePrimitiveCollectionTypes()
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var filters = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Operator = FilterOperation.Equals,
PropertyName = "_",
Value = "3"
}
}
},
PropertyName = nameof(TestModel.InnerPrimitiveList),
Operator = FilterOperation.Any
}
},
SortOptions = new List <SortOption>
{
new SortOption
{
PropertyName = nameof(TestModel.Age)
}
}
};
List <TestModel> result = currentSet.ApplyFilters(filters).ToList();
Assert.NotEmpty(result);
Assert.Equal(2, result.Count);
Assert.Equal(currentSet.ElementAtOrDefault(0), result[0]);
Assert.Equal(currentSet.ElementAtOrDefault(1), result[1]);
}
public void ApplyFiltersShouldApplyAllGivenQueryTypes()
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var allQueryTypes = new DynamicQueryOptions
{
PaginationOption = new PaginationOption
{
Count = 1,
Offset = 1
},
Filters = new List <Filter> {
new Filter {
Operator = FilterOperation.Equals, PropertyName = "Age", Value = "5"
}
}
};
allQueryTypes.SortOptions.AddRange(new SortOption[]
{
new SortOption
{
PropertyName = "Age",
SortingDirection = SortingDirection.Desc
}, new SortOption
{
PropertyName = "Name",
SortingDirection = SortingDirection.Asc,
CaseSensitive = true
}
});
IQueryable <TestModel> result = currentSet.ApplyFilters(allQueryTypes);
string expressionString = result.Expression.ToString();
string paramName = nameof(TestModel).ToLower();
Assert.Contains($".OrderByDescending({paramName} => {paramName}.{allQueryTypes.SortOptions[0].PropertyName})", expressionString);
Assert.Contains($".ThenBy({paramName} => {paramName}.{allQueryTypes.SortOptions[1].PropertyName}, value(System.CultureAwareComparer))", expressionString);
Assert.Contains($".Where({paramName} => ({paramName}.{allQueryTypes.Filters[0].PropertyName} == {allQueryTypes.Filters[0].Value})", expressionString);
Assert.Contains($".Skip({allQueryTypes.PaginationOption.Offset}).Take({allQueryTypes.PaginationOption.Offset})", expressionString);
}
