public void CommittedEvent_MappedToDomainEvent_IsValid() { var domainEventReadAdapter = new DomainEventReadAdapter(); var aggregateSequenceNumber = 5; var aggregateId = TestAggregateId.New; var aggregateEvent = new TestCreatedEvent(aggregateId); var now = DateTimeOffset.UtcNow; var eventId = EventId.NewDeterministic(GuidFactories.Deterministic.Namespaces.Events, $"{aggregateId.Value}-v{3}"); var eventMetadata = new EventMetadata { Timestamp = now, AggregateSequenceNumber = aggregateSequenceNumber, AggregateName = typeof(TestAggregate).GetAggregateName().Value, AggregateId = aggregateId.Value, EventId = eventId }; var committedEvent = new CommittedEvent <TestAggregateId, TestCreatedEvent>( aggregateId, aggregateEvent, eventMetadata, now, aggregateSequenceNumber); var eventSequence = domainEventReadAdapter.FromJournal(committedEvent, String.Empty); var upcastedEvent = eventSequence.Events.Single(); if (upcastedEvent is IDomainEvent <TestAggregateId, TestCreatedEvent> e) { e.AggregateEvent.GetType().Should().Be <TestCreatedEvent>(); } else { false.Should().BeTrue(); } }
public void CommittedEvent_WithUpgradableEvent_GetsUpgrades() { var aggregateEventUpcaster = new TestAggregateEventUpcaster(); var aggregateSequenceNumber = 3; var aggregateId = TestAggregateId.New; var aggregateEvent = new TestCreatedEvent(aggregateId); var now = DateTimeOffset.UtcNow; var eventId = EventId.NewDeterministic( GuidFactories.Deterministic.Namespaces.Events, $"{aggregateId.Value}-v{3}"); var eventMetadata = new Metadata { Timestamp = now, AggregateSequenceNumber = aggregateSequenceNumber, AggregateName = typeof(TestAggregate).GetAggregateName().Value, AggregateId = aggregateId.Value, EventId = eventId }; var committedEvent = new CommittedEvent <TestAggregate, TestAggregateId, TestCreatedEvent>( aggregateId, aggregateEvent, eventMetadata, now, aggregateSequenceNumber); var eventSequence = aggregateEventUpcaster.FromJournal(committedEvent, string.Empty); var upcastedEvent = eventSequence.Events.Single(); upcastedEvent .As <ICommittedEvent <TestAggregate, TestAggregateId, TestCreatedEventV2> >() .AggregateEvent.Name .Should().Be("default upcasted string"); }
public async Task TestCreateEvent() { // Arrange var eventStore = new EventStore.EventStore(_context, _provider, _provider.GetService <IEventDataFactory <EventData, Guid, Guid> >()); var aggregateId = Guid.NewGuid(); const int expectedVersion = 0; var expectedEventId = Guid.NewGuid(); var creationEvent = new TestCreatedEvent(expectedEventId, aggregateId, expectedVersion); // Act await eventStore.AddEventAsync(creationEvent); var events = eventStore.GetAllEvents(); var testEvents = events as IList <IEvent <Guid, Guid> > ?? events.ToList(); var testEvent = testEvents.First(); //var resultingAggregate = await eventStore.GetAsync<TestAggregate>(aggregateId); // Assert Assert.NotNull(eventStore); Assert.Equal(1, testEvents.Count); Assert.IsAssignableFrom <IEvent>(testEvent); Assert.IsType <TestCreatedEvent>(testEvent); Assert.Equal(aggregateId, testEvent.AggregateId); Assert.Equal(expectedVersion, testEvent.Version); Assert.Equal(expectedEventId, testEvent.Id); }
public async Task TestAddEvent() { // Arrange var eventStore = new EventStore.EventStore(_context, _provider, _provider.GetService <IEventDataFactory <EventData, Guid, Guid> >()); var aggregateId = Guid.NewGuid(); const int version = 0; const int secondVersion = 1; const int expectedVersion = 2; var expectedEventId = Guid.NewGuid(); var secondExpectedEventId = Guid.NewGuid(); const string updatedValue = "test"; var creationEvent = new TestCreatedEvent(expectedEventId, aggregateId, version); var updatedEvent = new UpdatedTestEvent(secondExpectedEventId, aggregateId, secondVersion, updatedValue); // Act await eventStore.AddEventAsync(creationEvent); await eventStore.AddEventAsync(updatedEvent); var aggregate = await eventStore.GetAggregateAsync <TestAggregate>(aggregateId); // Assert Assert.NotNull(eventStore); Assert.NotNull(aggregate); Assert.IsType <TestAggregate>(aggregate); Assert.Equal(updatedValue, aggregate.TestProperty); Assert.Equal(expectedVersion, aggregate.Version); }
public void SubscribeTest() { var testEvent = new TestCreatedEvent(); var signal = new OperationCompletedSignal(testEvent); var mock = new Mock <ISubscriptionClient>(); mock.Setup(s => s.RegisterSessionHandler(It.IsAny <Func <IMessageSession, Message, CancellationToken, Task> >(), It.IsAny <SessionHandlerOptions>())) .Callback <Func <IMessageSession, Message, CancellationToken, Task>, SessionHandlerOptions>((handler, _) => { var msg = CreateBusMessage(signal); var sessionMock = new Mock <IMessageSession>(); handler?.Invoke(sessionMock.Object, msg, CancellationToken.None); }); var logMock = new Mock <ILogger <AzureReportBusClient> >(); var reportBus = new AzureReportBusClient(logMock.Object, mock.Object); IMessage expectedMessage = null; reportBus.Subscribe(message => { expectedMessage = message; return(Task.CompletedTask); }); expectedMessage.Should().BeEquivalentTo(signal); }
public void ServiceBusMessageTest() { var e = new TestCreatedEvent(); var msg = e.ToBusMessage(); var tms = msg.GetEvent(); Assert.Equal(e.Id, tms.Id); }
public void CopyMetadataFromWhereMetadataContainsDataNotFromMetadataKeyEnum() { var cmd = new TestCreateCommand(); cmd.Metadata.Add((MetadataKey)111, "SomeCustomData"); var ev = new TestCreatedEvent(); cmd.CopyMetadata(ev); ev.Metadata[(MetadataKey)111].Should().Be("SomeCustomData"); }
public async Task PublishAsyncShoudAddMessageToStore() { var message = new TestCreatedEvent { AggregateRootId = "new Id" }; var sut = new FakeReportBus(new Dictionary <string, IMessage>()); await sut.PublishAsync(message); var expectedMessage = await sut.GetMessageAsync(message.AggregateRootId); expectedMessage.Should().BeEquivalentTo(message); }
public async Task SubscribeShoudAddMessageToStore() { var message = new TestCreatedEvent { AggregateRootId = "new Id" }; var sut = new FakeReportBusClient(); sut.Subscribe(msg => { msg.Should().BeEquivalentTo(message); return(Task.CompletedTask); }); await sut.PushTestEventAsync(message); }
public void CopyMetadataFromSuccessTest() { var cmd = new TestCreateCommand(); cmd.Metadata.Add(MetadataKey.AgreegateType, "Test"); cmd.Metadata.Add(MetadataKey.UserId, Unified.NewCode()); var ev = new TestCreatedEvent(); cmd.CopyMetadata(ev); ev.Metadata[MetadataKey.AgreegateType].Should().Be(cmd.Metadata[MetadataKey.AgreegateType]); ev.Metadata[MetadataKey.UserId].Should().Be(cmd.Metadata[MetadataKey.UserId]); ev.Metadata.TryGetValue(MetadataKey.RequestHeaders, out _).Should().BeFalse(); ev.Metadata.TryGetValue(MetadataKey.Roles, out _).Should().BeFalse(); }
public bool Execute(CreateAndAddTwoTestsCommand command) { if (IsNew) { var createdEvent = new TestCreatedEvent(command.AggregateId); var firstTestAddedEvent = new TestAddedEvent(command.FirstTest); var secondTestAddedEvent = new TestAddedEvent(command.SecondTest); EmitAll(createdEvent, firstTestAddedEvent, secondTestAddedEvent); Reply(TestExecutionResult.SucceededWith(command.SourceId)); } else { TestErrors++; Throw(new TestedErrorEvent(TestErrors)); ReplyFailure(TestExecutionResult.FailedWith(command.SourceId)); } return(true); }
public async Task <Result> Do(CreateAndAddTwoTestsCommand command) { if (IsNew) { var createdEvent = new TestCreatedEvent(command.Id); var firstTestAddedEvent = new TestAddedEvent(command.Id, command.FirstTest); var secondTestAddedEvent = new TestAddedEvent(command.Id, command.SecondTest); await Emit(createdEvent); await Emit(firstTestAddedEvent); await Emit(secondTestAddedEvent); return(Result.Success); } TestErrors++; await Emit(new TestedErrorEvent(Id, TestErrors)); return(Result.Fail("TestedErrorEvent")); }
private bool Execute(CreateAndAddTwoTestsCommand command) { if (IsNew) { var createdEvent = new TestCreatedEvent(command.AggregateId); var firstTestAddedEvent = new TestAddedEvent(command.FirstTest); var secondTestAddedEvent = new TestAddedEvent(command.SecondTest); var events = Events(createdEvent, firstTestAddedEvent, secondTestAddedEvent); //EmitAll(events, new Metadata {{"some-key","some-value"}}); EmitAll(createdEvent, firstTestAddedEvent, secondTestAddedEvent); Reply(TestExecutionResult.SucceededWith(command.SourceId)); } else { TestErrors++; Throw(new TestedErrorEvent(TestErrors)); ReplyFailure(TestExecutionResult.FailedWith(command.SourceId)); } return(true); }
public void CommittedEvent_Tagged_ContainsTaggedElements() { var aggregateEventTagger = new TestAggregateEventUpcaster(); var aggregateSequenceNumber = 3; var aggregateId = TestAggregateId.New; var aggregateEvent = new TestCreatedEvent(aggregateId); var now = DateTimeOffset.UtcNow; var eventId = EventId.NewDeterministic( GuidFactories.Deterministic.Namespaces.Events, $"{aggregateId.Value}-v{3}"); var eventMetadata = new Metadata { Timestamp = now, AggregateSequenceNumber = aggregateSequenceNumber, AggregateName = typeof(TestAggregate).GetAggregateName().Value, AggregateId = aggregateId.Value, EventId = eventId }; var committedEvent = new CommittedEvent <TestAggregate, TestAggregateId, TestCreatedEvent>( aggregateId, aggregateEvent, eventMetadata, now, aggregateSequenceNumber); var eventSequence = aggregateEventTagger.FromJournal(committedEvent, string.Empty); var upcastedEvent = eventSequence.Events.Single(); if (upcastedEvent is ICommittedEvent <TestAggregate, TestAggregateId, TestCreatedEventV2> e) { e.AggregateEvent.GetType().Should().Be <TestCreatedEventV2>(); } else { false.Should().BeTrue(); } }
public async Task TestGetVersion() { // Arrange var eventStore = new EventStore.EventStore(_context, _provider, _provider.GetService <IEventDataFactory <EventData, Guid, Guid> >()); var aggregateId = Guid.NewGuid(); const int version = 0; const int secondVersion = 1; const int expectedVersion = 2; var expectedEventId = Guid.NewGuid(); var secondExpectedEventId = Guid.NewGuid(); const string updatedValue = "test"; var creationEvent = new TestCreatedEvent(expectedEventId, aggregateId, version); var updatedEvent = new UpdatedTestEvent(secondExpectedEventId, aggregateId, secondVersion, updatedValue); // Act await eventStore.AddEventAsync(creationEvent); await eventStore.AddEventAsync(updatedEvent); int resultingVersion = await eventStore.GetAggregateVersionAsync(aggregateId); // Assert Assert.Equal(expectedVersion, resultingVersion); }
public TestCreatedEventV2 Upcast(TestCreatedEvent aggregateEvent) { return(new TestCreatedEventV2(aggregateEvent.TestAggregateId, "newArgs")); }
public TestCreatedEventV2 Upcast(TestCreatedEvent aggregateEvent) { return(new TestCreatedEventV2(aggregateEvent.TestAggregateId, "default upcasted string")); }
public void Apply(TestCreatedEvent aggregateEvent) { TestCollection = new List <Test>(); FromHydration = false; }
public void GetEntityIdMustReturnTestIdWhenCalled() { TestCreatedEvent e = new TestCreatedEvent(); Assert.Equal(e.TestId, e.GetEntityId()); }
public void Apply(TestCreatedEvent aggregateEvent) { TestCollection = new List <TestEntity>(); }