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 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 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 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 PairSelectionsController(ICache cache, IAuthTokenReader tokenReader, ITraceExporter traceExporter)
{
if (tokenReader == null)
{
throw new ArgumentNullException(nameof(tokenReader));
}
var userToken = tokenReader.GetToken();
var frogMine = new FrogMine(userToken, cache, DbUtils.ConnectionString, traceExporter);
_mine = new PairSelectionMine(userToken, frogMine, traceExporter);
}
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 Genesis(string user, string connectionString, ITraceExporter traceExporter)
{
_day = DateTime.MinValue;
var cache = new InProcessCache();
var tadpoleMine = new TadpoleMine(user, cache, connectionString, traceExporter);
_pondMine = new PondMine(user, cache, connectionString, traceExporter);
_frogMine = new FrogMine(user, cache, connectionString, traceExporter);
_pairSelectionMine = new PairSelectionMine(user, _frogMine, traceExporter);
_maturationEventMine = new MaturationEventMine(user, _frogMine, tadpoleMine, traceExporter);
_matingEventMine = new MatingEventMine(user, _frogMine, tadpoleMine, traceExporter);
_frogCountMine = new FrogCountMine(user, connectionString, traceExporter);
_tadpoleCountMine = new TadpoleCountMine(user, connectionString, traceExporter);
}
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 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 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 PairSelectionMine(string user, FrogMine frogMine, ITraceExporter traceExporter) :
base(user, new PairSelectionTerminalLayer(frogMine), traceExporter)
{
}
public MaturationEventMine(string user, FrogMine frogMine, TadpoleMine tadpoleMine, ITraceExporter traceExporter) :
base(user, new MaturationEventTerminalLayer(frogMine, tadpoleMine), traceExporter)
{
}
public PairSelectionTerminalLayer(FrogMine frogMine)
{
_frogMine = frogMine ?? throw new ArgumentNullException(nameof(frogMine));
}
public MatingEventTerminalLayer(FrogMine frogMine, TadpoleMine tadpoleMine)
{
_frogMine = frogMine ?? throw new ArgumentNullException(nameof(frogMine));
_tadpoleMine = tadpoleMine ?? throw new ArgumentNullException(nameof(tadpoleMine));
}
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);
}
