public async Task write()
{
var driver = new MemoryStorageDriver();
var stream = new MigrationStream <JObject>(driver);
await stream.WriteAsync(new[]
{
new KeyValuePair <uint, JObject>(11, new JObject {
{ "a", new JValue(10) }
}),
new KeyValuePair <uint, JObject>(42, new JObject {
{ "a", new JValue(20) }
}),
});
Assert.AreEqual((uint)42U, (uint)await stream.LastWrittenAsync());
var written = driver.Read(0L, 10240);
Assert.AreEqual((int)2, (int)written.Events.Count);
Assert.AreEqual((uint)11, (uint)written.Events[0].Sequence);
Assert.AreEqual("{\"a\":10}", Encoding.UTF8.GetString(written.Events[0].Contents));
Assert.AreEqual((uint)42, (uint)written.Events[1].Sequence);
Assert.AreEqual("{\"a\":20}", Encoding.UTF8.GetString(written.Events[1].Contents));
}
public async Task nothing()
{
var driver = new MemoryStorageDriver();
var stream = new MigrationStream <JObject>(driver);
Assert.AreEqual((uint)0U, (uint)await stream.LastWrittenAsync());
}
public async Task discard_after_fetch()
{
var driver = new MemoryStorageDriver();
var stream = new EventStream <IStreamEvent>(driver);
await stream.WriteAsync(Enumerable.Range(0, 20)
.Select(i => (IStreamEvent) new IntegerEvent(i)).ToArray());
stream = new EventStream <IStreamEvent>(driver);
while (await stream.FetchAsync())
{
}
await stream.DiscardUpTo(11);
Assert.Equal((uint)10, (uint)stream.Sequence);
var next = 10;
IStreamEvent e;
while ((e = stream.TryGetNext()) != null)
{
Assert.Equal(next, ((IntegerEvent)e).Integer);
++next;
}
Assert.Equal(next, 20);
}
private async Task SetupImpl()
{
Console.WriteLine("> setup");
var baseStringArray = Enumerable.Repeat(LargeEvt.BaseString, 1000).ToList();
var driver = new MemoryStorageDriver();
var stream = new EventStream <LargeEvt>(driver);
int seqNum = 0;
long pos;
while ((pos = driver.GetPosition()) <= 4 * 1024 * 1024)
{
seqNum++;
var toWrite = new LargeEvt(seqNum, baseStringArray);
await stream.WriteAsync(new[] { toWrite });
}
firstNotFitting = checked ((uint)seqNum);
// add five additional events, just to be safe
// and also to test DiscardUpTo(some events in the second 4Mb block)
for (int i = 0; i < 5; ++i)
{
seqNum++;
await stream.WriteAsync(new[] { new LargeEvt(seqNum, baseStringArray) });
}
lastEvent = checked ((uint)seqNum);
Console.WriteLine("< setup");
storeWithLargeEvents = driver;
}
public async Task with_restart()
{
var memory = new MemoryStorageDriver();
var cache = new Testing.InMemoryCache();
var ew = new EventStreamWrapper <TstEvent, CheckSequence>(
memory,
new [] { new CheckSequence.Projection() },
cache
);
await ew.AppendEventsAsync(new[] { new TstEvent(1) });
await ew.AppendEventsAsync(new[] { new TstEvent(2) });
await ew.AppendEventsAsync(new[] { new TstEvent(3) });
await ew.TrySaveAsync();
await ew.AppendEventsAsync(new[] { new TstEvent(4) });
await ew.AppendEventsAsync(new[] { new TstEvent(5) });
Assert.Equal(5u, ew.Current.LastEvt);
// try to read:
var ew2 = new EventStreamWrapper <TstEvent, CheckSequence>(
memory, new[] { new CheckSequence.Projection() },
cache);
await ew2.InitializeAsync();
Assert.Equal(5u, ew2.Current.LastEvt);
}
public async Task write_changing_position()
{
var driver = new MemoryStorageDriver();
var streamA = new EventStream <IStreamEvent>(driver);
var streamB = new EventStream <IStreamEvent>(driver);
var result = await streamA.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Equal(1u, result);
while (await streamB.FetchAsync())
{
}
result = await streamB.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Equal(2u, result);
result = await streamA.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Null(result);
while (await streamA.FetchAsync())
{
}
result = await streamA.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Equal(3u, result);
}
public async Task discard()
{
var driver = new MemoryStorageDriver();
var stream = new EventStream <IStreamEvent>(driver);
await stream.WriteAsync(Enumerable.Range(0, 20)
.Select(i => (IStreamEvent) new IntegerEvent(i)).ToArray());
stream = new EventStream <IStreamEvent>(driver);
await stream.DiscardUpTo(11);
Func <bool> shouldContinue;
var next = 10;
do
{
var task = stream.BackgroundFetchAsync();
IStreamEvent e;
while ((e = stream.TryGetNext()) != null)
{
Assert.Equal(next, ((IntegerEvent)e).Integer);
++next;
}
shouldContinue = await task;
} while (shouldContinue());
Assert.Equal(next, 20);
}
public async Task naive_read()
{
var driver = new MemoryStorageDriver();
var stream = new EventStream <IStreamEvent>(driver);
await stream.WriteAsync(Enumerable.Range(0, 20)
.Select(i => (IStreamEvent) new IntegerEvent(i)).ToArray());
stream = new EventStream <IStreamEvent>(driver);
while (await stream.FetchAsync())
{
}
var next = 0;
IStreamEvent e;
while ((e = stream.TryGetNext()) != null)
{
Assert.Equal(next, ((IntegerEvent)e).Integer);
++next;
}
Assert.Equal(next, 20);
}
public async Task write()
{
var driver = new MemoryStorageDriver();
var stream = new EventStream <IStreamEvent>(driver);
var result = await stream.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Equal(1u, result);
}
public async Task already_filled()
{
var driver = new MemoryStorageDriver();
driver.Write(0L, new[] { new RawEvent(42U, new byte[8]) });
var stream = new MigrationStream <JObject>(driver);
Assert.AreEqual((uint)42U, (uint)await stream.LastWrittenAsync());
}
/// <summary> Returns a configuration for an in-memory storage driver with initial data. </summary>
public static StorageConfiguration Initialize <TEvent>(params TEvent[] events) where TEvent : class
{
var msd = new MemoryStorageDriver();
var ms = new MigrationStream <TEvent>(msd);
ms.WriteAsync(events.Select((e, i) => new KeyValuePair <uint, TEvent>((uint)(i + 1), e)))
.Wait();
return(new StorageConfiguration(msd));
}
public async Task write_wrong_position()
{
var driver = new MemoryStorageDriver();
await driver.WriteAsync(0, new[] { new RawEvent(1U, new byte[8]) });
var stream = new EventStream <IStreamEvent>(driver);
var result = await stream.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Null(result);
}
public async Task write_multiple()
{
var driver = new MemoryStorageDriver();
var stream = new EventStream <IStreamEvent>(driver);
var result = await stream.WriteAsync(new IStreamEvent[] { new StreamEvent(), new StreamEvent() });
Assert.AreEqual((object)1, result);
result = await stream.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.AreEqual((object)3, result);
}
public async Task discard_above_end()
{
var driver = new MemoryStorageDriver();
var stream = new EventStream <IStreamEvent>(driver);
await stream.WriteAsync(Enumerable.Range(0, 20)
.Select(i => (IStreamEvent) new IntegerEvent(i)).ToArray());
stream = new EventStream <IStreamEvent>(driver);
while (await stream.FetchAsync())
{
}
await stream.DiscardUpTo(30);
Assert.Equal((uint)20, (uint)stream.Sequence);
}
public async Task write_restore_position()
{
var driver = new MemoryStorageDriver();
var stream = new EventStream <IStreamEvent>(driver);
await stream.WriteAsync(new IStreamEvent[] { new StreamEvent() });
stream = new EventStream <IStreamEvent>(driver);
var result = await stream.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Null(result);
while (await stream.FetchAsync())
{
}
result = await stream.WriteAsync(new IStreamEvent[] { new StreamEvent() });
Assert.Equal(2u, result);
}
public async Task without_restart()
{
var memory = new MemoryStorageDriver();
var ew = new EventStreamWrapper <TstEvent, CheckSequence>(
memory,
new [] { new CheckSequence.Projection() }, null
);
await ew.AppendEventsAsync(new[] { new TstEvent(1) });
await ew.AppendEventsAsync(new[] { new TstEvent(2) });
await ew.AppendEventsAsync(new[] { new TstEvent(3) });
Assert.Equal(3u, ew.Current.LastEvt);
// try to read:
var ew2 = new EventStreamWrapper <TstEvent, CheckSequence>(
memory, new[] { new CheckSequence.Projection() }, null);
await ew2.InitializeAsync();
Assert.Equal(3u, ew2.Current.LastEvt);
}
