public LocalTransportProxyActor()
{
var localTransport = new LocalAkkaEventBusTransport(Context.System);
Receive <Publish>(p =>
{
localTransport.Publish(p.Msg);
Sender.Tell(PublishAck.Instance);
});
Receive <PublishMany>(p =>
{
var messages = p.Messages.Select(m => m.Msg).ToArray();
localTransport.Publish(messages);
Sender.Tell(PublishManyAck.Instance);
});
Receive <Subscribe>(s =>
{
localTransport.Subscribe(s.Topic, s.Actor, s.Notificator);
Sender.Tell(SubscribeAck.Instance);
});
Receive <Unsubscribe>(us =>
{
localTransport.Unsubscribe(us.Actor, us.Topic);
Sender.Tell(UnsubscribeAck.Instance);
});
}
public void Message_process_actor_produce_fault_with_sagaId_from_incoming_message(string payload)
{
var message = new SampleAggregateChangedEvent(payload, Guid.NewGuid(), DateTime.Now, Guid.NewGuid());
var transport = new LocalAkkaEventBusTransport(Sys);
transport.Subscribe <IMessageMetadataEnvelop <Fault <SampleAggregateChangedEvent> > >(TestActor);
var actor = Sys.ActorOf(Props.Create(() =>
new MessageHandlingActor <SampleAggregateChangedEvent, OddFaultyMessageHandler>(
new OddFaultyMessageHandler(transport),
transport)));
actor.Tell(message);
var fault = ExpectMsg <IMessageMetadataEnvelop <Fault <SampleAggregateChangedEvent> > >();
Assert.AreEqual(message.SagaId, fault.Message.SagaId);
}
[InlineData("10")] //, Description = "planned exception from message processor")]
public void Message_process_actor_produce_fault_with_processId_from_incoming_message(string payload)
{
var message = new BalloonTitleChanged(payload, Guid.NewGuid().ToString(), DateTime.Now, Guid.NewGuid().ToString());
var transport = new LocalAkkaEventBusTransport(Sys);
transport.Subscribe <IMessageMetadataEnvelop>(TestActor);
var actor =
Sys.ActorOf(Props.Create(
() =>
new MessageHandleActor <BalloonTitleChanged, BalloonTitleChangedOddFaultyMessageHandler>(
new BalloonTitleChangedOddFaultyMessageHandler(transport),
transport)));
actor.Tell(new MessageMetadataEnvelop <DomainEvent>(message, MessageMetadata.Empty));
var fault = FishForMessage <IMessageMetadataEnvelop>(m => m.Message is IFault).Message as IFault;
Assert.Equal(message.ProcessId, fault.ProcessId);
Assert.IsAssignableFrom <Fault <BalloonTitleChanged> >(fault);
}
public void Aggregate_actor_produce_fault_with_sagaId_from_command()
{
var command = new GoSleepCommand(Guid.Empty, Guid.Empty).CloneWithSaga(Guid.NewGuid());
var transport = new LocalAkkaEventBusTransport(Sys);
transport.Subscribe <MessageMetadataEnvelop <Fault <GoSleepCommand> > >(TestActor);
var actor = Sys.ActorOf(Props.Create(() =>
new AggregateActor <HomeAggregate>(new HomeAggregateHandler(),
new TypedMessageActor <ScheduleCommand>(TestActor),
new TypedMessageActor <Unschedule>(TestActor),
transport,
new SnapshotsPersistencePolicy(TimeSpan.FromSeconds(1), 1, 5),
new AggregateFactory()
)),
AggregateActorName.New <HomeAggregate>(command.Id).Name);
actor.Tell(new MessageMetadataEnvelop <ICommand>(command, new MessageMetadata(command.Id)));
var fault = ExpectMsg <MessageMetadataEnvelop <Fault <GoSleepCommand> > >(TimeSpan.FromDays(1));
Assert.AreEqual(command.SagaId, fault.Message.SagaId);
}