public async Task PublishPendingEvents_does_not_fails_even_if_all_events_persisted() { // Arrange var userId = Guid.NewGuid(); var userCreated = fixture.Create <FakeUserCreated>(); var usernameChanged = fixture.Create <FakeUsernameChanged>(); var domainEvents = new DomainEvent[] { userCreated, usernameChanged }; RaiseEvents(userId, domainEvents); var envelopes = new List <Envelope>(domainEvents.Select(e => new Envelope(e))); var batchOperation = new TableBatchOperation(); envelopes .Select(e => PendingEventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); batchOperation.Clear(); envelopes .Select(e => EventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); // Act Func <Task> action = () => sut.PublishPendingEvents <FakeUser>(userId, CancellationToken.None); // Assert action.ShouldNotThrow(); }
public async Task PublishPendingEvents_commits_once( FakeUserCreated created, FakeUsernameChanged usernameChanged) { // Arrange var sourceId = Guid.NewGuid(); var events = new DomainEvent[] { created, usernameChanged }; RaiseEvents(sourceId, events); Mock.Get(mockDbContext.PendingEvents) .SetupData(events .Select(e => new Envelope(e)) .Select(e => PendingEvent.FromEnvelope(e, serializer)) .ToList()); var sut = new SqlEventPublisher( () => mockDbContext, serializer, messageBus); // Act await sut.PublishPendingEvents(sourceId, CancellationToken.None); // Assert Mock.Get(mockDbContext).Verify( x => x.SaveChangesAsync(CancellationToken.None), Times.Once()); }
public void Generic_object_serialization_with_anonymous_of_anonymous_types_does_not_throws() { var changeset = new DomainEvent[] { new SampleEvent("ciao"), new SampleEvent("foo") }; ClassWithAnonymousType classWithAnonymousType = new ClassWithAnonymousType() { DomainEvents = new[] { "foo", "bar" }, ExtraData = new { Events = changeset.Select(evt => new { evt.GetType().Name, Data = evt }).ToArray(), } }; var serialized = JsonConvert.SerializeObject(classWithAnonymousType, GetSettingsForTest()); var defaultSerialized = JsonConvert.SerializeObject(classWithAnonymousType, GetDefaultSettingsWithFullSerialization()); Console.WriteLine(serialized); Console.WriteLine(defaultSerialized); ClassWithAnonymousType test = JsonConvert.DeserializeObject <ClassWithAnonymousType>(defaultSerialized, GetDefaultSettingsWithFullSerialization()); Assert.DoesNotThrow(() => JsonConvert.DeserializeObject <ClassWithAnonymousType>(serialized, GetSettingsForTest())); }
public void Saga_state_should_contain_all_messages() { var messagesSent = new DomainEvent[] { _startMessage, _coffeMadeEvent, _reStartEvent }; CollectionAssert.AreEquivalent(messagesSent.Select(m => m.SourceId), _sagaDataAggregate.ReceivedMessages.Cast <DomainEvent>().Select(m => m.SourceId)); }
public async Task PublishAllEvents_sends_pending_events() { // Arrange var domainEvents = new List <DomainEvent>(); List <Guid> users = fixture.CreateMany <Guid>().ToList(); foreach (Guid userId in users) { var userCreated = fixture.Create <FakeUserCreated>(); var usernameChanged = fixture.Create <FakeUsernameChanged>(); var events = new DomainEvent[] { userCreated, usernameChanged }; RaiseEvents(userId, events); var envelopes = new List <Envelope>(events.Select(e => new Envelope(e))); var batchOperation = new TableBatchOperation(); envelopes .Select(e => PendingEventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); batchOperation.Clear(); envelopes .Select(e => EventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); domainEvents.AddRange(events); } var messages = new List <IDomainEvent>(); Mock.Get(messageBus) .Setup( x => x.SendBatch( It.IsAny <IEnumerable <Envelope> >(), It.IsAny <CancellationToken>())) .Callback <IEnumerable <Envelope>, CancellationToken>( (batch, cancellationToken) => messages.AddRange(batch .Select(b => b.Message) .OfType <IDomainEvent>() .Where(m => users.Contains(m.SourceId)))) .Returns(Task.FromResult(true)); // Act await sut.PublishAllEvents(CancellationToken.None); // Assert messages.Should().OnlyContain(e => e is IDomainEvent); messages.ShouldAllBeEquivalentTo(domainEvents); }
public async Task PublishPendingEvents_does_not_delete_pending_events_if_fails_to_send() { // Arrange var userId = Guid.NewGuid(); var userCreated = fixture.Create <FakeUserCreated>(); var usernameChanged = fixture.Create <FakeUsernameChanged>(); var domainEvents = new DomainEvent[] { userCreated, usernameChanged }; RaiseEvents(userId, domainEvents); var envelopes = new List <Envelope>(domainEvents.Select(e => new Envelope(e))); var batchOperation = new TableBatchOperation(); var pendingEvents = new List <PendingEventTableEntity>( envelopes.Select(e => PendingEventTableEntity.FromEnvelope <FakeUser>(e, serializer))); pendingEvents.ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); batchOperation.Clear(); envelopes .Take(1) .Select(e => EventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); Mock.Get(messageBus) .Setup( x => x.SendBatch( It.IsAny <IEnumerable <Envelope> >(), It.IsAny <CancellationToken>())) .Throws(new InvalidOperationException()); // Act try { await sut.PublishPendingEvents <FakeUser>(userId, CancellationToken.None); } catch (InvalidOperationException) { } // Assert string partitionKey = PendingEventTableEntity.GetPartitionKey(typeof(FakeUser), userId); var query = new TableQuery <PendingEventTableEntity>().Where($"PartitionKey eq '{partitionKey}'"); IEnumerable <object> actual = s_eventTable.ExecuteQuery(query).Select(e => e.RowKey); actual.ShouldAllBeEquivalentTo(pendingEvents.Select(e => e.RowKey)); }
public async Task PublishPendingEventss_sends_only_persisted_pending_events() { // Arrange var userId = Guid.NewGuid(); var userCreated = fixture.Create <FakeUserCreated>(); var usernameChanged = fixture.Create <FakeUsernameChanged>(); var domainEvents = new DomainEvent[] { userCreated, usernameChanged }; RaiseEvents(userId, domainEvents); var envelopes = new List <Envelope>(domainEvents.Select(e => new Envelope(e))); var batchOperation = new TableBatchOperation(); envelopes .Select(e => PendingEventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); batchOperation.Clear(); envelopes .Take(1) .Select(e => EventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); List <Envelope> batch = null; Mock.Get(messageBus) .Setup( x => x.SendBatch( It.IsAny <IEnumerable <Envelope> >(), It.IsAny <CancellationToken>())) .Callback <IEnumerable <Envelope>, CancellationToken>((b, t) => batch = b.ToList()) .Returns(Task.FromResult(true)); // Act await sut.PublishPendingEvents <FakeUser>(userId, CancellationToken.None); // Assert Mock.Get(messageBus).Verify( x => x.SendBatch( It.IsAny <IEnumerable <Envelope> >(), CancellationToken.None), Times.Once()); batch.ShouldAllBeEquivalentTo(envelopes.Take(1), opts => opts.RespectingRuntimeTypes()); }
public async Task SaveEvents_saves_events_correctly() { // Arrange var userId = Guid.NewGuid(); var created = new FakeUserCreated(); var usernameChanged = new FakeUsernameChanged(); var events = new DomainEvent[] { created, usernameChanged }; events.Raise(userId); var serializer = new JsonMessageSerializer(); var sut = new SqlEventStore( () => new FakeEventStoreDbContext(_dbContextOptions), serializer); // Act await sut.SaveEvents <FakeUser>(events); // Asseert using (var db = new FakeEventStoreDbContext(_dbContextOptions)) { IEnumerable <object> actual = db .PersistentEvents .Where(e => e.AggregateId == userId) .OrderBy(e => e.Version) .AsEnumerable() .Select(e => new { e.AggregateType, e.Version, e.EventType, Payload = serializer.Deserialize(e.EventJson), }) .ToList(); actual.Should().HaveCount(events.Length); IEnumerable <object> expected = events.Select(e => new { AggregateType = typeof(FakeUser).FullName, e.Version, EventType = e.GetType().FullName, Payload = e, }); actual.ShouldAllBeEquivalentTo(expected); } }
public async Task SaveEvents_saves_events_correctly() { // Arrange FakeUserCreated created = _fixture.Create <FakeUserCreated>(); FakeUsernameChanged usernameChanged = _fixture.Create <FakeUsernameChanged>(); var events = new DomainEvent[] { created, usernameChanged }; RaiseEvents(_userId, events); string operationId = _fixture.Create <string>(); var correlationId = Guid.NewGuid(); string contributor = _fixture.Create <string>(); // Act await _sut.SaveEvents <FakeUser>(events, operationId, correlationId, contributor); // Asseert using (var db = new DataContext()) { IEnumerable <object> actual = db .PersistentEvents .Where(e => e.AggregateId == _userId) .OrderBy(e => e.Version) .AsEnumerable() .Select(e => new { e.Version, e.EventType, e.OperationId, e.CorrelationId, e.Contributor, Payload = _serializer.Deserialize(e.EventJson), }) .ToList(); actual.Should().HaveCount(events.Length); IEnumerable <object> expected = events.Select(e => new { e.Version, EventType = e.GetType().FullName, OperationId = operationId, CorrelationId = correlationId, Contributor = contributor, Payload = e, }); actual.ShouldAllBeEquivalentTo(expected); } }
public async Task SaveEvents_saves_events_correctly( FakeUserCreated created, FakeUsernameChanged usernameChanged) { // Arrange var events = new DomainEvent[] { created, usernameChanged }; RaiseEvents(userId, events); // Act await sut.SaveEvents <FakeUser>(events); // Asseert using (var db = new DataContext()) { IEnumerable <object> actual = db .PersistentEvents .Where(e => e.AggregateId == userId) .OrderBy(e => e.Version) .AsEnumerable() .Select(e => new { e.Version, e.EventType, Payload = serializer.Deserialize(e.EventJson) }) .ToList(); actual.Should().HaveCount(events.Length); IEnumerable <object> expected = events.Select(e => new { Version = e.Version, EventType = e.GetType().FullName, Payload = e }); actual.ShouldAllBeEquivalentTo(expected); } }
public async Task PublishPendingEvents_deletes_all_pending_events() { // Arrange var userId = Guid.NewGuid(); var userCreated = fixture.Create <FakeUserCreated>(); var usernameChanged = fixture.Create <FakeUsernameChanged>(); var domainEvents = new DomainEvent[] { userCreated, usernameChanged }; RaiseEvents(userId, domainEvents); var envelopes = new List <Envelope>(domainEvents.Select(e => new Envelope(e))); var batchOperation = new TableBatchOperation(); envelopes .Select(e => PendingEventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); batchOperation.Clear(); envelopes .Take(1) .Select(e => EventTableEntity.FromEnvelope <FakeUser>(e, serializer)) .ForEach(batchOperation.Insert); await s_eventTable.ExecuteBatchAsync(batchOperation); // Act await sut.PublishPendingEvents <FakeUser>(userId, CancellationToken.None); // Assert string partitionKey = PendingEventTableEntity.GetPartitionKey(typeof(FakeUser), userId); var query = new TableQuery <PendingEventTableEntity>().Where($"PartitionKey eq '{partitionKey}'"); List <PendingEventTableEntity> actual = s_eventTable.ExecuteQuery(query).ToList(); actual.Should().BeEmpty(); }