public async Task Get()
{
var mine = new FrogMine();
// uncached
var basket = new GetBasket <int, Frog>(3);
await mine.SendAsync(basket).ConfigureAwait(false);
Assert.True(basket.Note is OkNote);
Assert.Equal(3, basket.AscentPayload.Id);
Assert.Equal("Kermit", basket.AscentPayload.Name);
Assert.Equal(3, basket.Visits.Count);
// cached
basket = new GetBasket <int, Frog>(3);
await mine.SendAsync(basket).ConfigureAwait(false);
Assert.True(basket.Note is ReturnNote);
Assert.Equal(3, basket.AscentPayload.Id);
Assert.Equal("Kermit", basket.AscentPayload.Name);
Assert.Equal(1, basket.Visits.Count);
// uncached
basket = new GetBasket <int, Frog>(4);
await mine.SendAsync(basket).ConfigureAwait(false);
Assert.True(basket.Note is OkNote);
Assert.Equal(4, basket.AscentPayload.Id);
Assert.Equal("Kermit", basket.AscentPayload.Name);
Assert.Equal(3, basket.Visits.Count);
}
public Task AddResultAsync(IPostBasket <Types.MatingEvent, string> basket, IVisit visit)
{
// get what we need out of the basket so that a response can be generated
var male = basket.DescentPayload.Male;
var female = basket.DescentPayload.Female;
var date = basket.DescentPayload.Date;
// we're going to patch the male and female, so there is a record of them mating
var modifiedProps = new Dictionary <string, object> {
{ nameof(Types.Frog.DateLastMated), date }
};
var patchMaleBasket = new PatchBasket <int, Types.Frog, int>(
new PatchRequest <int, Types.Frog>(new Delta <int, Types.Frog>(male.Id, modifiedProps)), basket);
var patchFemaleBaset = new PatchBasket <int, Types.Frog, int>(
new PatchRequest <int, Types.Frog>(new Delta <int, Types.Frog>(female.Id, modifiedProps)), basket);
// generate some children for the male and female
var tadpoleBaskets = GenerateTadpoles(basket, female, male, date);
Task.WaitAll(_frogMine.SendAsync(patchMaleBasket), _frogMine.SendAsync(patchFemaleBaset));
var tadpoleCount = tadpoleBaskets.Select(t => t.AscentPayload).Count();
// the result of this operation is a string
basket.AscentPayload = $"[{date:d}] {male.Name} and {female.Name} had {tadpoleCount} children";
return(Task.CompletedTask);
}
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);
}
private void Inhabit(Pond pond)
{
var frogam = new Frog {
Name = "Frogam", IsMale = true, LivesInPondId = pond.Id, DateOfBirth = _day
};
var freve = new Frog {
Name = "Freve", IsMale = false, LivesInPondId = pond.Id, DateOfBirth = _day
};
Task.WaitAll(
_frogMine.SendAsync(new PostBasket <Frog, int>(frogam)),
_frogMine.SendAsync(new PostBasket <Frog, int>(freve))
);
}
public async Task Patch()
{
var mine = new FrogMine("allowed");
var basket = new PatchBasket <int, Frog, int>(new PatchRequest <int, Frog>(new Delta <int, Frog>(5,
new Dictionary <string, object> {
{ nameof(Frog.Name), "abc" }
})));
await mine.SendAsync(basket);
Assert.Equal(1, basket.AscentPayload);
mine = new FrogMine("Patch");
basket = new PatchBasket <int, Frog, int>(new PatchRequest <int, Frog>(new Delta <int, Frog>(5,
new Dictionary <string, object> {
{ nameof(Frog.Name), "abc" }
})));
await mine.SendAsync(basket);
Assert.Equal(1, basket.AscentPayload);
mine = new FrogMine("not-allowed");
basket = new PatchBasket <int, Frog, int>(new PatchRequest <int, Frog>(new Delta <int, Frog>(5,
new Dictionary <string, object> {
{ nameof(Frog.Name), "abc" }
})));
await Assert.ThrowsAnyAsync <ShaftException>(() => mine.SendAsync(basket));
}
public async Task DeleteCollection()
{
var mine = new FrogMine("allowed");
var basket = new DeleteCollectionBasket <Frog, int>(new DeleteCollectionRequest <Frog>(new Filter <Frog>(new[]
{
new FilterTerm(nameof(Frog.Name), FilterOperators.StartsWith, "abc")
})));
await mine.SendAsync(basket);
Assert.Equal(5, basket.AscentPayload);
mine = new FrogMine("DeleteCollection");
basket = new DeleteCollectionBasket <Frog, int>(new DeleteCollectionRequest <Frog>(new Filter <Frog>(new[]
{
new FilterTerm(nameof(Frog.Name), FilterOperators.StartsWith, "abc")
})));
await mine.SendAsync(basket);
Assert.Equal(5, basket.AscentPayload);
mine = new FrogMine("not-allowed");
basket = new DeleteCollectionBasket <Frog, int>(new DeleteCollectionRequest <Frog>(new Filter <Frog>(new[]
{
new FilterTerm(nameof(Frog.Name), FilterOperators.StartsWith, "abc")
})));
await Assert.ThrowsAnyAsync <ShaftException>(() => mine.SendAsync(basket));
}
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 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);
}
private void InsertFrogs(FrogMine mine, int count)
{
var tasks = new Task[count];
for (var i = 1; i <= count; i++)
{
var frog = new Frog {
Name = $"Frank{i}", DateOfBirth = DateTime.Today.AddDays(-i)
};
tasks[i - 1] = mine.SendAsync(new PostBasket <Frog, int>(frog));
}
Task.WaitAll(tasks);
}
public async Task Post()
{
var mine = new FrogMine("allowed");
var basket = new PostBasket <Frog, int>(new Frog());
await mine.SendAsync(basket);
Assert.True(basket.AscentPayload > 0);
mine = new FrogMine("Post");
basket = new PostBasket <Frog, int>(new Frog());
await mine.SendAsync(basket);
Assert.True(basket.AscentPayload > 0);
mine = new FrogMine("not-allowed");
basket = new PostBasket <Frog, int>(new Frog());
await Assert.ThrowsAnyAsync <ShaftException>(() => mine.SendAsync(basket));
}
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 GetSingle()
{
var mine = new FrogMine("allowed");
var basket = new GetSingleBasket <Frog>();
await mine.SendAsync(basket);
Assert.Equal(465, basket.AscentPayload.Id);
mine = new FrogMine("GetSingle");
basket = new GetSingleBasket <Frog>();
await mine.SendAsync(basket);
Assert.Equal(465, basket.AscentPayload.Id);
mine = new FrogMine("not-allowed");
basket = new GetSingleBasket <Frog>();
await Assert.ThrowsAnyAsync <ShaftException>(() => mine.SendAsync(basket));
}
public async Task Delete()
{
var mine = new FrogMine("allowed");
var basket = new DeleteBasket <int, Frog, int>(6);
await mine.SendAsync(basket);
Assert.Equal(1, basket.AscentPayload);
mine = new FrogMine("Delete");
basket = new DeleteBasket <int, Frog, int>(6);
await mine.SendAsync(basket);
Assert.Equal(1, basket.AscentPayload);
mine = new FrogMine("not-allowed");
basket = new DeleteBasket <int, Frog, int>(6);
await Assert.ThrowsAnyAsync <ShaftException>(() => mine.SendAsync(basket));
}
public async Task Put()
{
var mine = new FrogMine("allowed");
var basket = new PutBasket <int, Frog, int>(new PutRequest <int, Frog>(2, new Frog()));
await mine.SendAsync(basket);
Assert.Equal(1, basket.AscentPayload);
mine = new FrogMine("Put");
basket = new PutBasket <int, Frog, int>(new PutRequest <int, Frog>(2, new Frog()));
await mine.SendAsync(basket);
Assert.Equal(1, basket.AscentPayload);
mine = new FrogMine("not-allowed");
basket = new PutBasket <int, Frog, int>(new PutRequest <int, Frog>(2, new Frog()));
await Assert.ThrowsAnyAsync <ShaftException>(() => mine.SendAsync(basket));
}
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 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);
}
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);
}
