public async Task ThenAllSnapshotsAreHard_Deleted()
{
var streamId = ScenarioContext.Current.GetStreamId();
var snapshotDocuments = await CosmosSetup.QueryAllDocumentsInStream <SnapshotDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, streamId);
Assert.IsEmpty(snapshotDocuments);
}
public async Task ThenAllSnapshotsAreHard_Deleted()
{
var streamId = this.Context.StreamId;
var snapshotDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, streamId, DocumentType.Snapshot);
Assert.IsEmpty(snapshotDocuments);
}
public async Task ThenTheEventInVersionInStreamIsReplaced(ulong version, string streamId)
{
var currentDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, streamId, DocumentType.Event);
var eventDocument = currentDocuments.SingleOrDefault(x => x.Id == EveneumDocument.GenerateEventId(streamId, version));
Assert.AreEqual(DocumentType.Event, eventDocument.DocumentType);
Assert.AreEqual(streamId, eventDocument.StreamId);
Assert.AreEqual(this.Context.EventStoreOptions.TypeProvider.GetIdentifierForType(this.Context.ReplacedEvent.Body.GetType()), eventDocument.BodyType);
Assert.NotNull(eventDocument.Body);
Assert.AreEqual(JToken.FromObject(this.Context.ReplacedEvent.Body, JsonSerializer.Create(this.Context.JsonSerializerSettings)), eventDocument.Body);
Assert.NotNull(eventDocument.ETag);
Assert.False(eventDocument.Deleted);
if (this.Context.ReplacedEvent.Metadata == null)
{
Assert.IsNull(eventDocument.MetadataType);
Assert.IsNull(eventDocument.Metadata);
}
else
{
Assert.AreEqual(this.Context.EventStoreOptions.TypeProvider.GetIdentifierForType(this.Context.ReplacedEvent.Metadata.GetType()), eventDocument.MetadataType);
Assert.NotNull(eventDocument.Metadata);
Assert.AreEqual(JToken.FromObject(this.Context.ReplacedEvent.Metadata, JsonSerializer.Create(this.Context.JsonSerializerSettings)), eventDocument.Metadata);
}
}
public async Task WhenIDeleteStreamInExpectedVersion(string streamId, ulong expectedVersion)
{
ScenarioContext.Current.SetStreamId(streamId);
ScenarioContext.Current.SetExistingDocuments(await CosmosSetup.QueryAllDocuments(this.Context.Client, this.Context.Database, this.Context.Collection));
await this.Context.EventStore.DeleteStream(ScenarioContext.Current.GetStreamId(), expectedVersion);
}
public async Task DeletedDocumentsAppearInChangeFeed(bool partitioned)
{
// Arrange
var partition = partitioned ? Guid.NewGuid().ToString() : null;
var client = await CosmosSetup.GetClient(this.Database, this.Collection, partitioned : partitioned);
var store = new EventStore(client, this.Database, this.Collection, partition);
var streamId = Guid.NewGuid().ToString();
var events = TestSetup.GetEvents(10);
await store.WriteToStream(streamId, events);
await store.CreateSnapshot(streamId, 2, 2);
await store.CreateSnapshot(streamId, 4, 4);
await store.CreateSnapshot(streamId, 8, 8);
// Act
var token = await this.GetCurrentChangeFeedToken(client, partition);
await store.DeleteStream(streamId, (ulong)events.Length);
// Assert
var documents = await this.LoadChangeFeed(client, partition, token);
Assert.AreEqual(1 + events.Length + 3, documents.Count);
foreach (var document in documents)
{
Assert.IsTrue(document.Deleted);
}
}
public async Task ThenSnapshotsAndNewerAreNotHard_Deleted(ulong version)
{
var snapshotDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, this.Context.StreamId, DocumentType.Snapshot);
var newerSnapshotDocuments = snapshotDocuments.Where(x => x.Version >= version);
Assert.IsNotEmpty(newerSnapshotDocuments);
}
public async Task ThenTheSnapshotsOlderThanAreHard_Deleted(ulong version)
{
var snapshotDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, this.Context.StreamId, DocumentType.Snapshot);
var olderSnapshotDocuments = snapshotDocuments.Where(x => x.Version < version);
Assert.IsEmpty(olderSnapshotDocuments);
}
public async Task WhenIAppendEventsToStreamInExpectedVersion(int events, string streamId, ushort expectedVersion)
{
ScenarioContext.Current.SetStreamId(streamId);
ScenarioContext.Current.SetNewEvents(TestSetup.GetEvents(events, expectedVersion + 1));
ScenarioContext.Current.SetExistingDocuments(await CosmosSetup.QueryAllDocuments(this.Context.Client, this.Context.Database, this.Context.Collection));
await this.Context.EventStore.WriteToStream(ScenarioContext.Current.GetStreamId(), ScenarioContext.Current.GetNewEvents(), expectedVersion, metadata : ScenarioContext.Current.GetHeaderMetadata());
}
public async Task WhenIWriteNewStreamWithEvents(string streamId, int events)
{
ScenarioContext.Current.SetStreamId(streamId);
ScenarioContext.Current.SetNewEvents(TestSetup.GetEvents(events));
ScenarioContext.Current.SetExistingDocuments(await CosmosSetup.QueryAllDocuments(this.Context.Client, this.Context.Database, this.Context.Collection));
await this.Context.EventStore.WriteToStream(ScenarioContext.Current.GetStreamId(), ScenarioContext.Current.GetNewEvents(), metadata : ScenarioContext.Current.GetHeaderMetadata());
}
public async Task WhenIDeleteStreamInExpectedVersion(string streamId, ulong expectedVersion)
{
this.Context.StreamId = streamId;
this.Context.ExistingDocuments = await CosmosSetup.QueryAllDocuments(this.Context.Client, this.Context.Database, this.Context.Container);
var response = await this.Context.EventStore.DeleteStream(streamId, expectedVersion);
this.Context.Response = response;
}
public async Task ThenStreamIsNotSoft_Deleted(string streamId)
{
var documents = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, streamId);
foreach (var document in documents)
{
Assert.IsFalse(document.Deleted);
}
}
public async Task ThenStreamIsNotSoft_Deleted(string streamId)
{
var documents = await CosmosSetup.QueryAllDocumentsInStream <EveneumDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, streamId);
foreach (var document in documents)
{
Assert.IsFalse(document.Deleted);
}
}
public async Task ThenSnapshotsAndNewerAreNotHard_Deleted(ulong version)
{
var streamId = ScenarioContext.Current.GetStreamId();
var currentDocuments = await CosmosSetup.QueryAllDocumentsInStream <SnapshotDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, streamId);
var newerSnapshotDocuments = currentDocuments.Where(x => x.Version >= version);
Assert.IsNotEmpty(newerSnapshotDocuments);
}
public async Task WhenIWriteNewStreamWithEvents(string streamId, int events)
{
this.Context.StreamId = streamId;
this.Context.NewEvents = TestSetup.GetEvents(events);
this.Context.ExistingDocuments = await CosmosSetup.QueryAllDocuments(this.Context.Client, this.Context.Database, this.Context.Container);
var response = await this.Context.EventStore.WriteToStream(this.Context.StreamId, this.Context.NewEvents, metadata : this.Context.HeaderMetadata);
this.Context.Response = response;
}
public async Task ThenTheHeaderIsSoft_Deleted()
{
var documents = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, this.Context.StreamId, DocumentType.Header);
Assert.AreEqual(1, documents.Count);
var headerDocument = documents[0];
Assert.IsTrue(headerDocument.Deleted);
}
public async Task WhenIAppendEventsToStreamInExpectedVersion(int events, string streamId, ushort expectedVersion)
{
this.Context.StreamId = streamId;
this.Context.NewEvents = TestSetup.GetEvents(events, expectedVersion + 1);
this.Context.ExistingDocuments = await CosmosSetup.QueryAllDocuments(this.Context.Client, this.Context.Database, this.Context.Container);
var response = await this.Context.EventStore.WriteToStream(this.Context.StreamId, this.Context.NewEvents, expectedVersion, metadata : this.Context.HeaderMetadata);
this.Context.Response = response;
}
public async Task ThenAllEventsAreSoft_Deleted()
{
var streamId = ScenarioContext.Current.GetStreamId();
var eventDocuments = await CosmosSetup.QueryAllDocumentsInStream <EventDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, streamId);
foreach (var eventDocument in eventDocuments)
{
Assert.IsTrue(eventDocument.Deleted);
}
}
public async Task ThenAllSnapshotsAreSoft_Deleted()
{
var streamId = this.Context.StreamId;
var snapshotDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, streamId, DocumentType.Snapshot);
foreach (var snapshotDocument in snapshotDocuments)
{
Assert.IsTrue(snapshotDocument.Deleted);
}
}
public async Task ThenNoEventsAreAppended()
{
var streamId = ScenarioContext.Current.GetStreamId();
var currentDocuments = await CosmosSetup.QueryAllDocumentsInStream <EventDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, streamId);
var existingDocumentIds = ScenarioContext.Current.GetExistingDocuments().Select(x => x.Id);
var newEventDocuments = currentDocuments.Where(x => !existingDocumentIds.Contains(x.Id));
Assert.IsEmpty(newEventDocuments);
}
public async Task ThenNoEventsAreAppended()
{
var streamId = this.Context.StreamId;
var currentDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, streamId, DocumentType.Event);
var existingDocumentIds = this.Context.ExistingDocuments.Select(x => x.Id);
var newEventDocuments = currentDocuments.Where(x => !existingDocumentIds.Contains(x.Id));
Assert.IsEmpty(newEventDocuments);
}
public async Task ThenSnapshotsAndNewerAreNotSoft_Deleted(ulong version)
{
var snapshotDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, this.Context.StreamId, DocumentType.Snapshot);
var newerSnapshotDocuments = snapshotDocuments.Where(x => x.Version >= version);
foreach (var newerSnapshotDocument in newerSnapshotDocuments)
{
Assert.IsFalse(newerSnapshotDocument.Deleted);
}
}
public async Task ThenTheSnapshotsOlderThanAreSoft_Deleted(ulong version)
{
var streamId = ScenarioContext.Current.GetStreamId();
var currentDocuments = await CosmosSetup.QueryAllDocumentsInStream <SnapshotDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, streamId);
var olderSnapshotDocuments = currentDocuments.Where(x => x.Version < version);
foreach (var olderSnapshotDocument in olderSnapshotDocuments)
{
Assert.IsTrue(olderSnapshotDocument.Deleted);
}
}
public async Task ThenTheHeaderVersionWithNoMetadataIsPersisted(ulong version)
{
var headerDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, this.Context.StreamId, DocumentType.Header);
Assert.AreEqual(1, headerDocuments.Count);
var headerDocument = headerDocuments[0];
Assert.AreEqual(DocumentType.Header, headerDocument.DocumentType);
Assert.AreEqual(this.Context.StreamId, headerDocument.StreamId);
Assert.AreEqual(version, headerDocument.Version);
Assert.AreEqual(version + EveneumDocument.GetOrderingFraction(DocumentType.Header), headerDocument.SortOrder);
Assert.IsNull(headerDocument.MetadataType);
Assert.IsFalse(headerDocument.Metadata.HasValues);
Assert.NotNull(headerDocument.ETag);
Assert.False(headerDocument.Deleted);
}
public async Task ThenTheHeaderVersionWithMetadataIsPersisted(ulong version)
{
var headerDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, this.Context.StreamId, DocumentType.Header);
Assert.AreEqual(1, headerDocuments.Count);
var headerDocument = headerDocuments[0];
Assert.AreEqual(DocumentType.Header, headerDocument.DocumentType);
Assert.AreEqual(this.Context.StreamId, headerDocument.StreamId);
Assert.AreEqual(version, headerDocument.Version);
Assert.AreEqual(version + EveneumDocument.GetOrderingFraction(DocumentType.Header), headerDocument.SortOrder);
Assert.AreEqual(this.Context.EventStoreOptions.TypeProvider.GetIdentifierForType(typeof(SampleMetadata)), headerDocument.MetadataType);
Assert.NotNull(headerDocument.Metadata);
Assert.AreEqual(JToken.FromObject(this.Context.HeaderMetadata), headerDocument.Metadata);
Assert.NotNull(headerDocument.ETag);
Assert.False(headerDocument.Deleted);
}
public async Task DeletedSnapshotAppearsInChangeFeed(bool partitioned)
{
// Arrange
var partition = partitioned ? Guid.NewGuid().ToString() : null;
var client = await CosmosSetup.GetClient(this.Database, this.Collection, partitioned : partitioned);
var store = new EventStore(client, this.Database, this.Collection, partition);
var streamId = Guid.NewGuid().ToString();
var events = TestSetup.GetEvents(10);
await store.WriteToStream(streamId, events);
await store.CreateSnapshot(streamId, 2, 2);
await store.CreateSnapshot(streamId, 4, 4);
await store.CreateSnapshot(streamId, 8, 8);
// Act
var token = await this.GetCurrentChangeFeedToken(client, partition);
await store.DeleteSnapshots(streamId, 8);
// Assert
var documents = await this.LoadChangeFeed(client, partition, token);
Assert.AreEqual(2, documents.Count);
var snapshots = documents.OfType <SnapshotDocument>().ToList();
Assert.AreEqual(2, snapshots.Count);
foreach (var snapshot in snapshots)
{
Assert.IsTrue(snapshot.Deleted);
Assert.Contains(snapshot.Version, new[] { 2, 4 });
}
}
public async Task ThenNewEventsAreAppended()
{
var streamId = this.Context.StreamId;
var currentDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, streamId, DocumentType.Event);
var existingDocumentIds = this.Context.ExistingDocuments.Select(x => x.Id);
var newEventDocuments = currentDocuments.Where(x => !existingDocumentIds.Contains(x.Id)).ToList();
var newEvents = this.Context.NewEvents;
Assert.AreEqual(newEventDocuments.Count, newEvents.Length);
foreach (var newEvent in newEvents)
{
var eventDocument = newEventDocuments.Find(x => x.Id == EveneumDocument.GenerateEventId(streamId, newEvent.Version));
Assert.IsNotNull(eventDocument);
Assert.AreEqual(DocumentType.Event, eventDocument.DocumentType);
Assert.AreEqual(streamId, eventDocument.StreamId);
Assert.AreEqual(this.Context.EventStoreOptions.TypeProvider.GetIdentifierForType(newEvent.Body.GetType()), eventDocument.BodyType);
Assert.NotNull(eventDocument.Body);
Assert.AreEqual(JToken.FromObject(newEvent.Body, JsonSerializer.Create(this.Context.JsonSerializerSettings)), eventDocument.Body);
Assert.NotNull(eventDocument.ETag);
Assert.False(eventDocument.Deleted);
if (newEvent.Metadata == null)
{
Assert.IsNull(eventDocument.MetadataType);
Assert.IsNull(eventDocument.Metadata);
}
else
{
Assert.AreEqual(this.Context.EventStoreOptions.TypeProvider.GetIdentifierForType(newEvent.Metadata.GetType()), eventDocument.MetadataType);
Assert.NotNull(eventDocument.Metadata);
Assert.AreEqual(JToken.FromObject(newEvent.Metadata, JsonSerializer.Create(this.Context.JsonSerializerSettings)), eventDocument.Metadata);
}
}
}
public async Task ThenNewEventsAreAppended()
{
var streamId = ScenarioContext.Current.GetStreamId();
var currentDocuments = await CosmosSetup.QueryAllDocumentsInStream <EventDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, streamId);
var existingDocumentIds = ScenarioContext.Current.GetExistingDocuments().Select(x => x.Id);
var newEventDocuments = currentDocuments.Where(x => !existingDocumentIds.Contains(x.Id)).ToList();
var newEvents = ScenarioContext.Current.GetNewEvents();
Assert.AreEqual(newEventDocuments.Count, newEvents.Length);
foreach (var newEvent in newEvents)
{
var eventDocument = newEventDocuments.Find(x => x.Partition == this.Context.Partition && x.Id == EventDocument.GenerateId(streamId, newEvent.Version));
Assert.IsNotNull(eventDocument);
Assert.AreEqual(DocumentType.Event, eventDocument.DocumentType);
Assert.AreEqual(streamId, eventDocument.StreamId);
Assert.AreEqual(newEvent.Body.GetType().AssemblyQualifiedName, eventDocument.BodyType);
Assert.NotNull(eventDocument.Body);
Assert.AreEqual(JToken.FromObject(newEvent.Body), eventDocument.Body);
Assert.NotNull(eventDocument.ETag);
Assert.False(eventDocument.Deleted);
if (newEvent.Metadata == null)
{
Assert.IsNull(eventDocument.MetadataType);
Assert.IsNull(eventDocument.Metadata);
}
else
{
Assert.AreEqual(newEvent.Metadata.GetType().AssemblyQualifiedName, eventDocument.MetadataType);
Assert.NotNull(eventDocument.Metadata);
Assert.AreEqual(JToken.FromObject(newEvent.Metadata), eventDocument.Metadata);
}
}
}
public async Task ThenEventsFromVersionToAreReturned(ulong fromVersion, ulong toVersion)
{
var stream = this.Context.Stream;
var allDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, stream.Value.StreamId, Documents.DocumentType.Event);
var eventDocuments = allDocuments.ToDictionary(x => x.Version);
Assert.IsTrue(stream.HasValue);
Assert.IsNotEmpty(stream.Value.Events);
Assert.AreEqual(toVersion - fromVersion + 1, stream.Value.Events.Length);
for (ulong version = fromVersion, index = 0; version <= toVersion; ++version, ++index)
{
var @event = stream.Value.Events[index];
Assert.AreEqual(version, @event.Version);
Assert.IsTrue(eventDocuments.ContainsKey(version));
var eventDocument = eventDocuments[version];
Assert.AreEqual(eventDocument.Metadata, JToken.FromObject(@event.Metadata));
}
}
public async Task ThenTheSnapshotForVersionIsPersisted(ulong version)
{
var streamId = this.Context.StreamId;
var snapshot = this.Context.Snapshot;
var snapshotDocuments = await CosmosSetup.QueryAllDocumentsInStream(this.Context.Client, this.Context.Database, this.Context.Container, this.Context.StreamId, DocumentType.Snapshot);
Assert.IsNotEmpty(snapshotDocuments);
var snapshotDocument = snapshotDocuments.Find(x => x.Version == version);
Assert.IsNotNull(snapshotDocument);
var snapshotMetadata = this.Context.SnapshotMetadata;
Assert.AreEqual(DocumentType.Snapshot, snapshotDocument.DocumentType);
Assert.AreEqual(streamId, snapshotDocument.StreamId);
Assert.AreEqual(version, snapshotDocument.Version);
Assert.AreEqual(version + EveneumDocument.GetOrderingFraction(DocumentType.Snapshot), snapshotDocument.SortOrder);
if (snapshotMetadata == null)
{
Assert.IsNull(snapshotDocument.MetadataType);
Assert.IsFalse(snapshotDocument.Metadata.HasValues);
}
else
{
Assert.AreEqual(snapshotMetadata.GetType().AssemblyQualifiedName, snapshotDocument.MetadataType);
Assert.AreEqual(JToken.FromObject(snapshotMetadata), snapshotDocument.Metadata);
}
Assert.AreEqual(snapshot.GetType().AssemblyQualifiedName, snapshotDocument.BodyType);
Assert.AreEqual(JToken.FromObject(snapshot), snapshotDocument.Body);
Assert.False(snapshotDocument.Deleted);
Assert.IsNotNull(snapshotDocument.ETag);
}
public async Task ThenTheHeaderIsHard_Deleted()
{
var documents = await CosmosSetup.QueryAllDocumentsInStream <HeaderDocument>(this.Context.Client, this.Context.Database, this.Context.Collection, this.Context.PartitionKey, ScenarioContext.Current.GetStreamId());
Assert.IsEmpty(documents);
}
