public void Should_calculate_group_aggregate_if_paged()
{
IEnumerable <Person> people = new[] { new Person {
Name = "A"
}, new Person {
Name = "A"
}, new Person {
Name = "B"
} };
var queryablePeople = QueryableFactory.CreateQueryable(people);
var groupDescriptor = new GroupDescriptor {
Member = "Name", MemberType = typeof(string)
};
groupDescriptor.AggregateFunctions.Add(new CountFunction());
var groupDescriptors = new[] { groupDescriptor };
var notPagedData = queryablePeople;
var result = queryablePeople.Page(0, 1).GroupBy(notPagedData, groupDescriptors);
var groups = result.Cast <AggregateFunctionsGroup>();
groups.Count().ShouldEqual(1);
groups.ElementAt(0).GetAggregateResults(groupDescriptor.AggregateFunctions).First().Value.ShouldEqual(2);
}
/// <summary>
/// Creates a Queryable with a transaction.
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
public IMultipleQueryable <TItem> WithTransaction(DbTransaction transaction)
{
return(QueryableFactory.NewMultiple(
ConfigurationBuilder.New(commandType)
.WithTransaction(transaction)
.BuildAsMultiple(collection)
));
}
/// <summary>
/// Creates a Queryable with a specific connection.
/// </summary>
/// <param name="connectionString"></param>
/// <returns></returns>
public IMultipleQueryable <TItem> WithConnection(string connectionString)
{
return(QueryableFactory.NewMultiple(
ConfigurationBuilder.New(commandType)
.WithConnection(connectionString)
.BuildAsMultiple(collection)
));
}
private IQueryable CreateTestData()
{
IList <Person> people = new List <Person>();
for (int i = 0; i < 10; i++)
{
people.Add(new Person {
ID = i, Name = "Person#" + i
});
}
return(QueryableFactory.CreateQueryable(people));
}
public void Sort_without_member()
{
var strings = new[] { "One", "Two" };
var queryableStrings = QueryableFactory.CreateQueryable(strings);
var sortedStrings = queryableStrings.Sort(new[] {
new SortDescriptor {
SortDirection = ListSortDirection.Descending
}
}).Cast <string>();
Assert.Equal("Two", sortedStrings.First());
}
public void Should_calculate_group_aggregate_on_multiple_groups()
{
IEnumerable <Person> people = new[] { new Person {
ID = 0, Name = "A"
}, new Person {
ID = 1, Name = "A"
}, new Person {
ID = 2, Name = "B"
} };
var queryablePeople = QueryableFactory.CreateQueryable(people);
var outterGroup = new GroupDescriptor {
Member = "Name", MemberType = typeof(string)
};
outterGroup.AggregateFunctions.Add(new CountFunction());
var innerGroup = new GroupDescriptor {
Member = "ID", MemberType = typeof(string)
};
innerGroup.AggregateFunctions.Add(new CountFunction());
var groupDescriptors = new[] { outterGroup, innerGroup };
var result = queryablePeople.GroupBy(queryablePeople, groupDescriptors);
var groups = result.Cast <AggregateFunctionsGroup>();
groups.Count().ShouldEqual(2);
var firstGroupHeader = FindGroupHeader(groups, 0);
var secondGroupHeader = FindGroupHeader(groups, 1);
firstGroupHeader.GetAggregateResults(outterGroup.AggregateFunctions).First().Value.ShouldEqual(2);
secondGroupHeader.GetAggregateResults(outterGroup.AggregateFunctions).First().Value.ShouldEqual(1);
var firstInnerGroupHeader = FindGroupHeader(firstGroupHeader.Items, 0);
firstInnerGroupHeader.GetAggregateResults(innerGroup.AggregateFunctions).First().Value.ShouldEqual(1);
var secondInnerGroupHeader = FindGroupHeader(firstGroupHeader.Items, 1);
secondInnerGroupHeader.GetAggregateResults(innerGroup.AggregateFunctions).First().Value.ShouldEqual(1);
}
public void Should_filter_a_list_of_dynamic_types_on_complex_property()
{
dynamic expando = new System.Dynamic.ExpandoObject();
expando.Foo = new Customer {
Name = "Name1"
};
IEnumerable <object> enumerable = new[] { expando };
var data = QueryableFactory.CreateQueryable(enumerable).Where(new[] { new FilterDescriptor
{
Member = "Foo.Name",
Operator = FilterOperator.IsEqualTo,
Value = "Name1",
} });
Assert.NotNull(data.ElementAt(0));
}
public void Sort_should_sort_the_data()
{
IEnumerable <Person> people = new[] { new Person {
Name = "A"
}, new Person {
Name = "B"
} };
var quearyablePeople = QueryableFactory.CreateQueryable(people);
var sortedPeople = quearyablePeople.Sort(new[] {
new SortDescriptor {
Member = "Name",
SortDirection = ListSortDirection.Descending
}
}).Cast <Person>();
Assert.Equal("B", sortedPeople.First().Name);
}
public void Filter_string_not_equal_caseinsensitive()
{
IEnumerable <Person> people = new[] { new Person {
Name = "A"
}, new Person {
Name = "B"
} };
var quearyablePeople = QueryableFactory.CreateQueryable(people);
var filteredPeople = quearyablePeople.Where(new[] { new FilterDescriptor
{
Member = "Name",
Operator = FilterOperator.IsNotEqualTo,
Value = "a"
} }).Cast <Person>();
Assert.Same(people.ElementAt(1), filteredPeople.FirstOrDefault());
}
public void Should_filter_a_list_of_dynamic_types()
{
dynamic expando = new System.Dynamic.ExpandoObject();
expando.Foo = "Bar";
var enumerable =
new System.Dynamic.IDynamicMetaObjectProvider[] { expando };
var data = QueryableFactory.CreateQueryable(enumerable)
.Where(new[] { new FilterDescriptor
{
Member = "Foo",
Operator = FilterOperator.IsEqualTo,
Value = "Bar"
} }
);
Assert.NotNull(data.ElementAt(0));
}
public SqlQueryable_Delete_Tests()
{
_Queryable = QueryableFactory<SysUser>.SQLServerQueryable();
_Queryable.Clear();
}
public SqlQueryable_Select_Tests()
{
sqlQuery = QueryableFactory <SysUser> .SQLServerQueryable();
sqlQuery.Clear();
}
public Dapper_Select_Tests()
{
_Repository = new DapperRepository <SysUser>();
_Queryable = QueryableFactory <SysUser> .SQLServerQueryable();
}
