public async Task DeleteCollection()
{
var layer = GetLayer();
InsertFrogs(layer, 10);
var deleteBasket = new DeleteCollectionBasket <Frog, int>(
new DeleteCollectionRequest <Frog>(new Filter <Frog>(new[]
{ new InFilterTerm(nameof(Frog.Id), new object[] { 2, 4, 6, 8 }) })));
await layer.AddResultAsync(deleteBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(4, deleteBasket.AscentPayload);
var getBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await layer.AddResultAsync(getBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(6, getBasket.AscentPayload.Length);
foreach (var frog in getBasket.AscentPayload)
{
Assert.NotEqual(2, frog.Id);
Assert.NotEqual(4, frog.Id);
Assert.NotEqual(6, frog.Id);
Assert.NotEqual(8, frog.Id);
}
}
public async Task GetCollection()
{
var layer = new SalesforceLayer <MyContact>(_forceClient, new MyContactObjectDescriptor());
var getBasket = new GetCollectionBasket <MyContact>(new GetCollectionRequest <MyContact>(10, 20));
await layer.AddResultAsync(getBasket, new Visit("GetCol", VisitDirections.Down)).ConfigureAwait(false);
Assert.True(getBasket.AscentPayload.Length == 10);
}
public void Construct()
{
var filter = new Filter <Frog>(new[] { new FilterTerm(nameof(Frog.Name), FilterOperators.StartsWith, "Fr") });
var request = new GetCollectionRequest <Frog>(filter);
var basket = new GetCollectionBasket <Frog>(request);
Assert.Equal(typeof(Frog), basket.DataType);
Assert.Same(request, basket.DescentPayload);
}
public Task AddResultAsync(IGetSingleBasket <Types.PairSelection> basket, IVisit visit)
{
var date = basket?.DescentPayload?.Filter?.Terms?.FirstOrDefault(
t => t.PropertyName == nameof(Types.PairSelection.Date))?.Value as DateTime?;
if (date == null)
{
throw new ArgumentException($"Expected filter on '{nameof(Types.PairSelection.Date)}'");
}
// only consider males which haven't mated in the past 3 months
var maleFilter = new Filter <Types.Frog>(new[]
{
new FilterTerm(nameof(Types.Frog.IsMale), FilterOperators.Equal, true),
new FilterTerm(nameof(Types.Frog.DateLastMated), FilterOperators.LessThan, date.Value.AddMonths(-3))
});
// ... and the same for females
var femaleFilter = new Filter <Types.Frog>(new[]
{
new FilterTerm(nameof(Types.Frog.IsMale), FilterOperators.Equal, false),
new FilterTerm(nameof(Types.Frog.DateLastMated), FilterOperators.LessThan, date.Value.AddMonths(-3))
});
// Try and find a suitable pair.
// In a real application you would most likely have a single efficient DB query. Here I just want to
// demonstrate operating across different mines.
// Note that the main basket is pased into these "child" baskets. This is optional however doing this allows
// for the baskets to be linked together when exporting tracing information (see FileTraceExporter)
var getMaleBasket =
new GetCollectionBasket <Types.Frog>(new GetCollectionRequest <Types.Frog>(maleFilter, 1, 0), basket);
var getMaleTask = _frogMine.SendAsync(getMaleBasket);
var getFemaleBasket =
new GetCollectionBasket <Types.Frog>(new GetCollectionRequest <Types.Frog>(femaleFilter, 1, 0), basket);
var getFemaleTask = _frogMine.SendAsync(getFemaleBasket);
Task.WaitAll(getMaleTask, getFemaleTask);
Types.Frog male = null;
if (getMaleBasket.AscentPayload.Length > 0)
{
male = getMaleBasket.AscentPayload[0];
}
Types.Frog female = null;
if (getFemaleBasket.AscentPayload.Length > 0)
{
female = getFemaleBasket.AscentPayload[0];
}
basket.AscentPayload = new Types.PairSelection(male, female, date.Value);
return(Task.CompletedTask);
}
public async Task GetAll()
{
var layer = GetLayer();
InsertFrogs(layer, 100);
var getBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await layer.AddResultAsync(getBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(100, getBasket.AscentPayload.Length);
}
public async Task Post()
{
var mine = new FrogMine();
// uncached item
var getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is OkNote);
Assert.Equal(3, getBasket.Visits.Count);
Assert.Equal(33, getBasket.AscentPayload.Id);
// cached item
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is ReturnNote);
Assert.Equal(1, getBasket.Visits.Count);
Assert.Equal(33, getBasket.AscentPayload.Id);
// uncached collection
var getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.Visits.Count);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
// cached collection
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is ReturnNote);
Assert.Equal(1, getCollectionBasket.Visits.Count);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
await mine.SendAsync(new PostBasket <Frog, int>(new Frog {
Id = 852
})).ConfigureAwait(false);
// get cache should still exist
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is ReturnNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// but get collection shouldn't
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
}
public async Task GetFiltered()
{
var layer = GetLayer();
InsertFrogs(layer, 100);
var getBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>(new Filter <Frog>(new[]
{ new FilterTerm(nameof(Frog.DateOfBirth), FilterOperators.LessThan, DateTime.Today.AddDays(-50)) })));
await layer.AddResultAsync(getBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(50, getBasket.AscentPayload.Length);
}
public async Task GetCollection()
{
var mine = new FrogMine("allowed");
var basket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(basket);
Assert.Equal(3, basket.AscentPayload.Length);
mine = new FrogMine("GetCollection");
basket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(basket);
Assert.Equal(3, basket.AscentPayload.Length);
mine = new FrogMine("not-allowed");
basket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await Assert.ThrowsAnyAsync <ShaftException>(() => mine.SendAsync(basket));
}
public async Task GetPaged()
{
var layer = GetLayer();
InsertFrogs(layer, 100);
for (var i = 0; i < 16; i++)
{
var getBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>(6, i));
await layer.AddResultAsync(getBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(6, getBasket.AscentPayload.Length);
}
var getFinalBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>(6, 16));
await layer.AddResultAsync(getFinalBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(4, getFinalBasket.AscentPayload.Length);
}
public async Task GetCollection()
{
var mine = new FrogMine();
// uncached
var basket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(basket).ConfigureAwait(false);
Assert.True(basket.Note is OkNote);
Assert.Equal(3, basket.Visits.Count);
Assert.Equal(3, basket.AscentPayload.Length);
// cached
basket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(basket).ConfigureAwait(false);
Assert.True(basket.Note is ReturnNote);
Assert.Equal(1, basket.Visits.Count);
Assert.Equal(3, basket.AscentPayload.Length);
}
public async Task AddResultAsync(IPostBasket <Types.MaturationEvent, int> basket, IVisit visit)
{
var date = basket.DescentPayload.Date;
var filter = new Filter <Types.Tadpole>(new[]
{
new FilterTerm(nameof(Types.Tadpole.DateOfBirth), FilterOperators.LessThanOrEqual, date.AddMonths(-2))
});
// get all tadpoles who are of a certain age - see filter above
var getTadpolesBasket =
new GetCollectionBasket <Types.Tadpole>(new GetCollectionRequest <Types.Tadpole>(filter));
await _tadpoleMine.SendAsync(getTadpolesBasket).ConfigureAwait(false);
var tadpoles = getTadpolesBasket.AscentPayload;
if (tadpoles.Length > 0)
{
// covert the retrieved tadpoles into frogs...
foreach (var tadpole in tadpoles)
{
var frog = tadpole.ToFrog();
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
// ... create frog
var postFrogBasket = new PostBasket <Types.Frog, int>(frog);
var postFrogTask = _frogMine.SendAsync(postFrogBasket);
// ...and get rid of the tapole which has now become a frog
var deleteTadpoleBasket = new DeleteBasket <int, Types.Tadpole, int>(tadpole.Id);
var deleteTadpoleTask = _tadpoleMine.SendAsync(deleteTadpoleBasket);
Task.WaitAll(postFrogTask, deleteTadpoleTask);
scope.Complete();
}
}
}
basket.AscentPayload = tadpoles.Length;
}
public async Task Delete()
{
var layer = GetLayer();
InsertFrogs(layer, 10);
var deleteBasket = new DeleteBasket <int, Frog, int>(4);
await layer.AddResultAsync(deleteBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(1, deleteBasket.AscentPayload);
var getBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await layer.AddResultAsync(getBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(9, getBasket.AscentPayload.Length);
foreach (var frog in getBasket.AscentPayload)
{
Assert.NotEqual(4, frog.Id);
}
}
public async Task Patch()
{
var layer = GetLayer();
InsertFrogs(layer, 10);
var patchBasket = new PatchBasket <int, Frog, int>(
new PatchRequest <int, Frog>(new Delta <int, Frog>(7,
new Dictionary <string, object> {
{ nameof(Frog.Name), "Patched" }
})));
await layer.AddResultAsync(patchBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
Assert.Equal(1, patchBasket.AscentPayload);
var getBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await layer.AddResultAsync(getBasket, new Visit("something", VisitDirections.Down)).ConfigureAwait(false);
var seenPatched = false;
Assert.Equal(10, getBasket.AscentPayload.Length);
foreach (var frog in getBasket.AscentPayload)
{
if (frog.Id == 7)
{
Assert.Equal("Patched", frog.Name);
seenPatched = true;
}
else
{
Assert.Equal($"Frank{frog.Id}", frog.Name);
}
}
Assert.True(seenPatched);
}
public async Task Delete()
{
var mine = new FrogMine();
// uncached item
var getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is OkNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// cached item
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is ReturnNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// uncached collection
var getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
// cached collection
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is ReturnNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
await mine.SendAsync(new DeleteBasket <int, Frog, int>(8)).ConfigureAwait(false);
// get cache should still exist
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is ReturnNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// but get collection shouldn't
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
await mine.SendAsync(new DeleteBasket <int, Frog, int>(33)).ConfigureAwait(false);
// get cache should now be cleared exist
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is OkNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// and so should the get collection's
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
}
public async Task Patch()
{
var mine = new FrogMine();
// uncached item
var getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is OkNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// cached item
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is ReturnNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// uncached collection
var getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
// cached collection
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is ReturnNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
await mine.SendAsync(new PatchBasket <int, Frog, int>(
new PatchRequest <int, Frog>(
new Delta <int, Frog>(8, new Dictionary <string, object> {
{ nameof(Frog.Name), "a" }
}))))
.ConfigureAwait(false);
// get cache should still exist
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is ReturnNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// but get collection shouldn't
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
await mine.SendAsync(new PatchBasket <int, Frog, int>(
new PatchRequest <int, Frog>(
new Delta <int, Frog>(33, new Dictionary <string, object> {
{ nameof(Frog.Name), "a" }
}))))
.ConfigureAwait(false);
// get cache should now be cleared exist
getBasket = new GetBasket <int, Frog>(33);
await mine.SendAsync(getBasket).ConfigureAwait(false);
Assert.True(getBasket.Note is OkNote);
Assert.Equal(33, getBasket.AscentPayload.Id);
// and so should the get collection's
getCollectionBasket = new GetCollectionBasket <Frog>(new GetCollectionRequest <Frog>());
await mine.SendAsync(getCollectionBasket).ConfigureAwait(false);
Assert.True(getCollectionBasket.Note is OkNote);
Assert.Equal(3, getCollectionBasket.AscentPayload.Length);
}
