public Task SubscribeTwoConsumer_SendOneMessage_BothConsumerReceivesMessage()
{
return(TryTest(async() =>
{
// arrange
var cts = new CancellationTokenSource(30000);
var eventDescription = new EventDescription(
Guid.NewGuid().ToString());
// act
IEventStream consumerOne = await _registry
.SubscribeAsync(eventDescription);
IEventStream consumerTwo = await _registry
.SubscribeAsync(eventDescription);
var outgoing = new EventMessage(eventDescription, "bar");
await _sender.SendAsync(outgoing);
// assert
IEventMessage incomingOne =
await consumerOne.ReadAsync(cts.Token);
IEventMessage incomingTwo =
await consumerTwo.ReadAsync(cts.Token);
Assert.Equal(outgoing.Payload, incomingOne.Payload);
Assert.Equal(outgoing.Payload, incomingTwo.Payload);
}));
}
public Task SubscribeTwoConsumer_SendTwoMessage_BothConsumerReceivesIndependentMessage()
{
return(TryTest(async() =>
{
// arrange
var cts = new CancellationTokenSource(30000);
string name = Guid.NewGuid().ToString();
var eventDescriptionOne = new EventDescription(
name, new ArgumentNode("b", "x"));
var eventDescriptionTwo = new EventDescription(
name, new ArgumentNode("b", "y"));
// act
IEventStream consumerOne = await _registry
.SubscribeAsync(eventDescriptionOne);
var outgoingOne = new EventMessage(eventDescriptionOne, "foo");
await _sender.SendAsync(outgoingOne);
IEventStream consumerTwo = await _registry
.SubscribeAsync(eventDescriptionTwo);
var outgoingTwo = new EventMessage(eventDescriptionTwo, "bar");
await _sender.SendAsync(outgoingTwo);
// assert
IEventMessage incomingOne =
await consumerOne.ReadAsync(cts.Token);
IEventMessage incomingTwo =
await consumerTwo.ReadAsync(cts.Token);
Assert.Equal(outgoingOne.Payload, incomingOne.Payload);
Assert.Equal(outgoingTwo.Payload, incomingTwo.Payload);
Assert.NotEqual(incomingOne.Event, incomingTwo.Event);
}));
}
public async Task Subscribe_ObjectValueArgument_Send_MessageReceived()
{
// arrange
var eventRegistry = new InMemoryEventRegistry();
var a = new EventDescription("event",
new ArgumentNode("foo", new ObjectValueNode(
new ObjectFieldNode("a", 123),
new ObjectFieldNode("b", true),
new ObjectFieldNode("c", "abc"))));
var b = new EventDescription("event",
new ArgumentNode("foo", new ObjectValueNode(
new ObjectFieldNode("b", true),
new ObjectFieldNode("a", 123),
new ObjectFieldNode("c", "abc"))));
// act
IEventStream stream =
await eventRegistry.SubscribeAsync(a);
// assert
var incoming = new EventMessage(b, "foo");
await eventRegistry.SendAsync(incoming);
IEventMessage outgoing = await stream.ReadAsync();
Assert.Equal(incoming, outgoing);
}
public async Task <IQueryExecutionResult> ReadAsync(
CancellationToken cancellationToken)
{
if (IsCompleted)
{
throw new InvalidOperationException(
"The response stream has already been completed.");
}
using (var ct = CancellationTokenSource.CreateLinkedTokenSource(
_cancellationTokenSource.Token, cancellationToken))
{
IEventMessage message = await _eventStream.ReadAsync(ct.Token);
return(await ExecuteQueryAsync(message, ct.Token));
}
}
public async Task Subscribe_Send_MessageReveived()
{
// arrange
var eventDescription = new EventDescription("foo");
var eventRegistry = new InMemoryEventRegistry();
// act
IEventStream stream =
await eventRegistry.SubscribeAsync(eventDescription);
// assert
var incoming = new EventMessage("foo");
await eventRegistry.SendAsync(incoming);
IEventMessage outgoing = await stream.ReadAsync();
Assert.Equal(incoming, outgoing);
}
public async Task <TAggregate> GetAsync(string aggregateId, CancellationToken cancellationToken = default)
{
if (string.IsNullOrWhiteSpace(aggregateId))
{
throw new ArgumentException("AggregateId must not be null or empty");
}
var aggregate = new TAggregate();
var eventStreamContext = await _eventStream.ReadAsync(aggregateId, cancellationToken);
if (eventStreamContext.Events != null)
{
aggregate.Rehydrate(eventStreamContext.Events);
}
aggregate.ConcurrencyKey = eventStreamContext.ConcurrencyKey;
return(aggregate);
}