public async Task FlattenedSelect()
{
var q = provider.Parse <PersonDTOFlattenedAuto>();
Assert.NotNull(q);
Assert.NotNull(q.Filter);
Assert.NotNull(q.Sorting);
var filterExpression = q.GetFilterExpression();
var sortExpression = q.GetSorting();
var res = await repository.GetPage(filterExpression, sortExpression, 1, 10);
Assert.NotNull(res);
Assert.Equal(res.TotalCount, 4);
Assert.Equal(res.Data.Count, 4);
var first = res.Data.First();
Assert.Equal(first.Name, "Root3");
Assert.Equal(first.SpouseName, "SpouseName3");
Assert.Equal(first.SpouseSurname, "SpouseSurname3");
Assert.Equal(first.Children.Count(), 4);
var firstChild = first.Children.First();
Assert.Equal(firstChild.Name, "Name3Children");
Assert.Equal(firstChild.SpouseName, "SpouseName3Children");
Assert.Equal(firstChild.SpouseSurname, "SpouseSurname3Children");
Assert.Equal(first.SpouseChildren.Count(), 4);
firstChild = first.SpouseChildren.First();
Assert.Equal(firstChild.Name, "Name3SpouseChildren");
Assert.Equal(firstChild.SpouseName, "SpouseName3SpouseChildren");
Assert.Equal(firstChild.SpouseSurname, "SpouseSurname3SpouseChildren");
}
public async Task NestedWithSorting(string command, int totalResults, string firstVAlue, int nChildren)
{
provider.OrderBy = command;
if (string.IsNullOrWhiteSpace(provider.OrderBy))
{
provider.OrderBy = "Id asc";
}
var q = provider.Parse <ReferenceTypeWithChildren>();
Assert.NotNull(q);
var sortingClause = q.GetSorting();
var res = await repository.GetPage <ReferenceTypeWithChildren>(
null,
sortingClause,
1, 10
);
Assert.Equal(res.TotalCount, totalResults);
Assert.NotNull(res.Data);
Assert.Equal(res.Data.Count, totalResults);
if (firstVAlue != null)
{
Assert.Equal(res.Data.First().AString, firstVAlue);
Assert.Equal(res.Data.First().Children.Count(), nChildren);
int nCount = 0;
foreach (var child in res.Data.First().Children)
{
Assert.Equal(child.AInt, nCount);
nCount++;
}
}
}
public void Paging(int from, int howMany, int page)
{
provider.Skip = from.ToString();
provider.Top = howMany.ToString();
var res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.Equal(res.Skip, from);
Assert.Equal(res.Take, howMany);
Assert.Equal(res.Page, page);
Assert.Equal(res.ToString().Replace(" ", ""), "?$skip=" + res.Skip.ToString() + "&$top=" + res.Take.ToString());
}
public void ConstantsEncoding(string filter, Type valueType, string propertyName, object value)
{
provider.Filter = filter;
var res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Filter);
Assert.Equal(res.Filter.Operator, QueryFilterBooleanOperator.and);
Assert.Null(res.Filter.Child1);
Assert.Null(res.Filter.Child2);
Assert.Null(res.Filter.Argument2);
var cond = res.Filter.Argument1;
Assert.NotNull(cond);
Assert.Equal(cond.Operator, "eq");
Assert.Equal(cond.Property, propertyName);
Assert.NotNull(cond.Value);
Assert.IsType(valueType, cond.Value);
if (value != null)
{
if (value is string && valueType != typeof(string))
{
var conv = TypeDescriptor.GetConverter(valueType);
value = conv.ConvertFrom(
context: null,
culture: CultureInfo.InvariantCulture,
value: value);
}
Assert.Equal(cond.Value, value);
}
}
public async Task Update()
{
var id = context.Persons.Where(m => m.Name == "Root0")
.Select(m => m.Id)
.SingleOrDefault();
var dto = new PersonDTOFlattenedAuto()
{
Id = id,
Name = "Root0",
Surname = "SurnameModified0",
SpouseName = "SpouseName0",
SpouseSurname = "SpouseSurnameModified0"
};
repository.Update(false, dto);
await repository.SaveChanges();
var q = provider.Parse <PersonDTOFlattenedAuto>();
Assert.NotNull(q);
Assert.NotNull(q.Filter);
Assert.NotNull(q.Sorting);
var filterExpression = q.GetFilterExpression();
var sortExpression = q.GetSorting();
var res = await repository.GetPage(filterExpression, sortExpression, 1, 10);
var first = res.Data.First();
Assert.Equal(first.Name, "Root0");
Assert.Equal(first.Surname, "SurnameModified0");
Assert.Equal(first.SpouseName, "SpouseName0");
Assert.Equal(first.SpouseSurname, "SpouseSurnameModified0");
}
public void ParseToString(string search, int op)
{
provider.Search = search;
var res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Search);
Assert.NotNull(res.Search.Value);
provider.Search = res.Search.ToString();
res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Search);
Assert.NotNull(res.Search.Value);
Assert.Equal(res.Search.Value.Operator, op);
Assert.Equal(res.Search.ToString(), provider.Search);
}
public async Task RightGrouping(string command, int totalResults, int?firstVAlue)
{
provider.Apply = command;
var q = provider.Parse <ReferenceType>();
var atype = new { AString = 7, ABool = 12, a = 1, b = 2 };
Assert.NotNull(q);
var groupingClause = q.GetGrouping();
var res = await repository.GetPage <ReferenceType>(
null,
(x => x.OrderBy(m => m.Id)),
1, 10,
groupingClause
);
Assert.Equal(res.TotalCount, totalResults);
Assert.NotNull(res.Data);
Assert.Equal(res.Data.Count, totalResults);
if (firstVAlue != null)
{
Assert.Equal(res.Data.First().AInt, firstVAlue.Value);
}
}
public async Task Operators(string filter, int all)
{
provider.Filter = filter;
var q = provider.Parse <ReferenceType>();
Assert.NotNull(q);
Assert.NotNull(q.Filter);
var filterExpression = q.GetFilterExpression();
var res = await repository.GetPage <ReferenceType>(
filterExpression,
x => x.OrderBy(m => m.Id),
1, 10
);
Assert.Equal(res.TotalCount, all);
Assert.NotNull(res.Data);
Assert.Equal(res.Data.Count, all);
}
public void QueryableToInternal(string filter)
{
provider.Filter = filter;
var res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Filter);
filter = res.Filter.ToString();
var linQExpression = res.GetFilterExpression();
Assert.NotNull(linQExpression);
var iFilter = QueryFilterClause.FromLinQExpression(linQExpression);
var filter1 = iFilter.ToString();
Assert.Equal(filter, filter1);
}
public void ParseToString(string sorting, int count)
{
provider.OrderBy = sorting;
var res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Sorting);
Assert.Equal(res.Sorting.Count, count);
var nf = res.EncodeSorting();
Assert.Equal(nf.Replace(" ", ""), sorting.Replace(" ", ""));
}
public void AddingQueryableToInternalFilter(string filter, string toAdd, bool isOr)
{
provider.Filter = filter;
var res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
if (!string.IsNullOrEmpty(filter))
{
Assert.NotNull(res.Filter);
}
var ifilter1 = res.Filter;
var iRes1 = res;
provider = new ODataQueryProvider();
provider.Filter = toAdd;
res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Filter);
var ifilter2 = res.Filter;
var iRes2 = res;
var totalFilter = isOr ? string.Format("({0}) or ({1})", filter, toAdd)
: string.Format("({0}) and ({1})", filter, toAdd);
provider = new ODataQueryProvider();
provider.Filter = string.IsNullOrEmpty(filter) ? toAdd : totalFilter;
res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Filter);
var iTotalFilter = res.Filter;
var linQToAdd = iRes2.GetFilterExpression();
Assert.NotNull(linQToAdd);
iRes1.AddFilterCondition(linQToAdd, isOr);
Assert.Equal(iRes1.Filter.ToString(), iTotalFilter.ToString());
}
public void GroupDetail(string grouping, string result)
{
provider.Apply = grouping;
var res = provider.Parse <ReferenceType>();
var allKeys = res.Grouping.Keys;
provider = new ODataQueryProvider();
provider.Filter = result;
var res1 = provider.Parse <ReferenceType>();
var filter = res1.AddToUrl("http://dummy.com/");
object model = new ReferenceType();
foreach (var key in allKeys)
{
res1.GetFilterCondition(typeof(ReferenceType), key, 0, ref model);
}
string computedFilter = res.GetGroupDetailUrl(model as ReferenceType, "http://dummy.com/");
Assert.Equal(computedFilter.Replace("(", "").Replace(")", ""), filter.Replace("(", "").Replace(")", ""));
}
public async Task RightSorting(string command, int totalResults, string firstVAlue)
{
provider.OrderBy = command;
var q = provider.Parse <ReferenceType>();
Assert.NotNull(q);
var sortingClause = q.GetSorting();
var res = await repository.GetPage <ReferenceType>(
null,
sortingClause ?? (x => x.OrderBy(m => m.Id)),
1, 10
);
Assert.Equal(res.TotalCount, totalResults);
Assert.NotNull(res.Data);
Assert.Equal(res.Data.Count, totalResults);
if (firstVAlue != null)
{
Assert.Equal(res.Data.First().AString, firstVAlue);
}
}
public void ParseToString(string groupby, int keysCount, int aggCounts)
{
provider.Apply = groupby;
var res = provider.Parse <ReferenceType>();
Assert.NotNull(res);
Assert.NotNull(res.Grouping);
Assert.NotNull(res.Grouping.Keys);
Assert.Equal(res.Grouping.Keys.Count, keysCount);
if (res.Grouping.Aggregations != null)
{
Assert.Equal(res.Grouping.Aggregations.Count, aggCounts);
}
else
{
Assert.Equal(aggCounts, 0);
}
Assert.Equal(groupby.Replace(" ", ""), res.Grouping.ToString().Replace(" ", ""));
}
