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>();
}
