public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.Add(new DataItem {
Int32 = 1, NullableByte = 1
});
dbSet.Add(new DataItem {
Int32 = 2, NullableByte = 2
});
context.SaveChanges();
var loadResult = DataSourceLoader.Load(dbSet, new SampleLoadOptions {
TotalSummary = new[] {
new SummaryInfo {
SummaryType = "sum", Selector = nameof(DataItem.Int32)
},
new SummaryInfo {
SummaryType = "sum", Selector = nameof(DataItem.NullableByte)
}
}
});
Assert.Equal(
new object[] { 3m, 3m },
loadResult.summary
);
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.Add(new DataItem());
dbSet.Add(new DataItem {
OrderDate = new DateTime(2009, 9, 9), Freight = 199
});
context.SaveChanges();
var loadResult = DataSourceLoader.Load(dbSet, new SampleLoadOptions {
Group = new[] {
new GroupingInfo {
Selector = "OrderDate", IsExpanded = false, GroupInterval = "quarter"
},
new GroupingInfo {
Selector = "Freight", IsExpanded = false, GroupInterval = "50"
}
}
});
var groups = loadResult.data.Cast <Group>().ToArray();
Assert.Null(groups[0].key);
Assert.Null((groups[0].items[0] as Group).key);
Assert.Equal(3, groups[1].key);
Assert.Equal(150m, (groups[1].items[0] as Group).key);
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.AddRange(new[] {
new DataItem {
Duration = TimeSpan.Parse("01:23")
},
new DataItem {
Duration = TimeSpan.Parse("02:23")
},
new DataItem {
Duration = TimeSpan.Zero
}
});
context.SaveChanges();
var loadResult = DataSourceLoader.Load(dbSet, new SampleLoadOptions {
Filter = new[] { "Duration", "contains", "23" }
});
var data = (IEnumerable <DataItem>)loadResult.data;
Assert.Equal(2, data.Count());
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.Add(new DataItem {
Blob = new byte[] { 143, 93, 183 }
});
context.SaveChanges();
var loadOptions = new SampleLoadOptions {
PreSelect = new[] { "ID", "Name", "BlobUrl" },
};
var error = Record.Exception(delegate {
DataSourceLoader.Load(dbSet, loadOptions).data.Cast <object>().First();
});
Assert.Contains("member 'BlobUrl' is not supported ", error.Message);
loadOptions.RemoteSelect = false;
var loadResult = DataSourceLoader.Load(dbSet, loadOptions);
var item = loadResult.data.Cast <IDictionary <string, object> >().First();
Assert.Equal(3, item.Keys.Count);
Assert.True(item.ContainsKey("ID"));
Assert.True(item.ContainsKey("Name"));
Assert.Equal("blob:j123", item["BlobUrl"]);
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(async context => {
var set = context.Set <DataItem>();
set.AddRange(AsyncTestHelper.CreateTestData(() => new DataItem()));
await context.SaveChangesAsync();
await AsyncTestHelper.RunAsync(set);
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.AddRange(SummaryTestHelper.GenerateTestData(() => new DataItem()));
context.SaveChanges();
SummaryTestHelper.Run(dbSet);
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.Add(new DataItem());
context.SaveChanges();
RemoteGroupingStressHelper.Run(dbSet);
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var set = context.Set <PaginateViaPrimaryKey_DataItem>();
foreach (var i in PaginateViaPrimaryKeyTestHelper.CreateTestData <PaginateViaPrimaryKey_DataItem>())
{
set.Add(i);
}
context.SaveChanges();
PaginateViaPrimaryKeyTestHelper.Run(set);
PaginateViaPrimaryKeyTestHelper.Run(set.Select(i => new { i.K1, i.K2 }));
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.Add(new DataItem {
ID = 1, Prop = 0
});
dbSet.Add(new DataItem {
ID = 2, Prop = 2
});
dbSet.Add(new DataItem {
ID = 0, Prop = 1
});
context.SaveChanges();
var projection = dbSet.Select(i => new { i.ID, i.Prop });
// Default settings: auto-sort by first sortable member (ID)
{
var loadResult = DataSourceLoader.Load(projection, new SampleLoadOptions {
Skip = 1,
Take = 99
});
var data = ImplicitCast(projection, loadResult.data);
Assert.Equal(
new[] { 1, 2 },
data.Select(i => i.ID)
);
}
// User-provided DefaultSort
{
var loadResult = DataSourceLoader.Load(projection, new SampleLoadOptions {
Skip = 1,
Take = 999,
DefaultSort = "Prop"
});
var data = ImplicitCast(projection, loadResult.data);
Assert.Equal(
new[] { 1, 2 },
data.Select(i => i.Prop)
);
}
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.Add(new DataItem());
context.SaveChanges();
var loadResult = DataSourceLoader.Load(dbSet, new SampleLoadOptions {
Select = new[] { "Date.Year", "Text.Length" }
});
var items = loadResult.data.Cast <dynamic>().ToArray();
Assert.Null(items[0].Date.Year);
Assert.Null(items[0].Text.Length);
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var parents = context.Set <ParentItem>();
var children = context.Set <ChildItem>();
var parent = new ParentItem {
ID = 123
};
var child = new ChildItem {
ID = 1
};
var orphan = new ChildItem {
ID = 2
};
parent.Children.Add(child);
parents.Add(parent);
children.Add(orphan);
context.SaveChanges();
{
var loadResut = DataSourceLoader.Load(children, new SampleLoadOptions {
Select = new[] { "Parent.ID" },
Sort = new[] {
new SortingInfo {
Selector = "Parent.ID"
}
}
});
dynamic items = loadResut.data.Cast <object>().ToArray();
Assert.Null(items[0].Parent.ID);
Assert.Equal(123, items[1].Parent.ID);
}
{
var loadResult = DataSourceLoader.Load(children, new SampleLoadOptions {
Filter = new[] { "Parent.ID", null }
});
Assert.Single(loadResult.data);
}
{
var loadResult = DataSourceLoader.Load(children, new SampleLoadOptions {
Filter = new[] { "Parent.ID", "<>", null }
});
Assert.Single(loadResult.data);
}
{
var loadResult = DataSourceLoader.Load(children, new SampleLoadOptions {
Filter = new[] { "ID", null }
});
Assert.Empty(loadResult.data);
}
});
}
public async Task Scenario()
{
await TestDbContext.ExecAsync(context => {
var dbSet = context.Set <DataItem>();
dbSet.AddRange(new[] {
new DataItem {
Group = "A", Value = 1
},
new DataItem {
Group = "A", Value = 3
},
new DataItem {
Group = "A", Value = null
},
new DataItem {
Group = "B", Value = 5
},
new DataItem {
Group = "B", Value = null
},
});
context.SaveChanges();
var loadResult = DataSourceLoader.Load(dbSet, new SampleLoadOptions {
Group = new[] {
new GroupingInfo {
Selector = "Group", IsExpanded = false
}
},
GroupSummary = new[] {
new SummaryInfo {
SummaryType = "avg", Selector = "Value"
},
new SummaryInfo {
SummaryType = "count"
},
new SummaryInfo {
SummaryType = "sum", Selector = "Value"
}
},
TotalSummary = new[] {
new SummaryInfo {
SummaryType = "sum", Selector = "Value"
},
new SummaryInfo {
SummaryType = "count"
},
new SummaryInfo {
SummaryType = "avg", Selector = "Value"
}
}
});
var loadResultGroups = loadResult.data.Cast <ResponseModel.Group>().ToArray();
var referenceGroups = dbSet
.GroupBy(i => i.Group)
.OrderBy(g => g.Key)
.Select(g => new {
Avg = g.Average(i => i.Value),
Count = g.Count(),
Sum = g.Sum(i => i.Value)
})
.ToArray();
for (var g = 0; g < 2; g++)
{
Assert.Equal((decimal)referenceGroups[g].Avg, loadResultGroups[g].summary[0]);
Assert.Equal(referenceGroups[g].Count, loadResultGroups[g].summary[1]);
Assert.Equal((decimal)referenceGroups[g].Sum, loadResultGroups[g].summary[2]);
}
Assert.Equal((decimal)dbSet.Sum(i => i.Value), loadResult.summary[0]);
Assert.Equal(dbSet.Count(), loadResult.summary[1]);
Assert.Equal((decimal)dbSet.Average(i => i.Value), loadResult.summary[2]);
});
}
