public Process_actor_should_execute_async_processes_with_block(ITestOutputHelper output)
{
var logger = new XUnitAutoTestLoggerConfiguration(output).CreateLogger();
var creator = new AsyncLongRunningProcessManagerFactory();
_localAkkaEventBusTransport = Sys.InitLocalTransportExtension().Transport;
var blackHole = Sys.ActorOf(BlackHoleActor.Props);
var messageProcessActor = Sys.ActorOf(Props.Create(() => new HandlersPipeActor(new HandlersDefaultProcessor(), blackHole)));
_processId = Guid.NewGuid().ToString();
var container = new ContainerBuilder();
container.Register <ProcessStateActor <TestState> >(c =>
new ProcessStateActor <TestState>(CommandAggregateHandler.New <ProcessStateAggregate <TestState> >(),
new EachMessageSnapshotsPersistencePolicy(),
AggregateFactory.Default,
AggregateFactory.Default,
messageProcessActor));
Sys.AddDependencyResolver(new AutoFacDependencyResolver(container.Build(), Sys));
Sys.AttachSerilogLogging(logger);
//for process state retrival
var processStateActor = Sys.ActorOf(Props.Create(() => new ProcessStateHubActor <TestState>(new DefaultRecycleConfiguration())), typeof(TestState).BeautyName() + "_Hub");
var name = EntityActorName.New <ProcessStateAggregate <TestState> >(_processId).Name;
_processActor = ActorOfAsTestActorRef(() => new ProcessActor <TestState>(new AsyncLongRunningProcess(), creator),
name);
}
public void Actors_should_resolve_named_dependencies()
{
var container = new ContainerBuilder();
container.RegisterInstance(new SomeService("A")).Named <SomeService>("A");
container.RegisterInstance(new SomeService("B")).Named <SomeService>("B");
container.Register <NamedActorA>(c => new NamedActorA(c.ResolveNamed <SomeService>("A")));
container.Register <NamedActorB>(c => new NamedActorB(c.ResolveNamed <SomeService>("B")));
Sys.AddDependencyResolver(new AutoFacDependencyResolver(container.Build(), Sys));
var actorA = ActorOfAsTestActorRef <NamedActorA>(Sys.DI().Props <NamedActorA>());
var actorB = ActorOfAsTestActorRef <NamedActorB>(Sys.DI().Props <NamedActorB>());
Assert.Equal("A", actorA.UnderlyingActor.Dep.Name);
Assert.Equal("B", actorB.UnderlyingActor.Dep.Name);
}
public void Actors_should_resolve_named_dependencies()
{
var container = new UnityContainer();
container.RegisterInstance("A", new SomeService("A"));
container.RegisterInstance("B", new SomeService("B"));
container.RegisterType <NamedActorA>(new InjectionFactory(c => new NamedActorA(c.Resolve <SomeService>("A"))));
container.RegisterType <NamedActorB>(new InjectionFactory(c => new NamedActorB(c.Resolve <SomeService>("B"))));
Sys.AddDependencyResolver(new UnityDependencyResolver(container, Sys));
var actorA = ActorOfAsTestActorRef <NamedActorA>(Sys.DI().Props <NamedActorA>());
var actorB = ActorOfAsTestActorRef <NamedActorB>(Sys.DI().Props <NamedActorB>());
Assert.AreEqual("A", actorA.UnderlyingActor.Dep.Name);
Assert.AreEqual("B", actorB.UnderlyingActor.Dep.Name);
}
public SchedulerActorTests(ITestOutputHelper helper)
{
var containerBuilder = new ContainerBuilder();
var log = new XUnitAutoTestLoggerConfiguration(helper, LogEventLevel.Verbose, this.GetType().Name).CreateLogger();
containerBuilder.RegisterInstance <ILogger>(log);
var publisherMoq = new Mock <IPublisher>();
containerBuilder.RegisterInstance(publisherMoq.Object);
Sys.AddDependencyResolver(new AutoFacDependencyResolver(containerBuilder.Build(), Sys));
Sys.InitLocalTransportExtension();
var ext = Sys.InitSchedulingExtension(new InMemoryQuartzConfig(), log, new Mock <IPublisher>().Object, new Mock <ICommandExecutor>().Object);
_scheduler = ext.SchedulingActor;
_quartzScheduler = ext.Scheduler;
}
private void CheckWriteModel(IReadOnlyCollection <BalanceChangePlan> balanceManipulationPlans)
{
Sys.AddDependencyResolver(new UnityDependencyResolver(GridNode.Container, Sys));
var props = Sys.DI().Props <AggregateActor <Account> >();
Console.WriteLine();
var aggregateActors = new List <Tuple <BalanceChangePlan, AggregateActor <Account> > >();
foreach (var plan in balanceManipulationPlans)
{
Console.WriteLine($"Checking write model for account {plan.AccountId}");
var name = AggregateActorName.New <Account>(plan.AccountId).ToString();
var balanceActor = ActorOfAsTestActorRef <AggregateActor <Account> >(props, name);
aggregateActors.Add(Tuple.Create(plan, balanceActor.UnderlyingActor));
}
//TODO: remove this dirty hack for wait until actors recover
Thread.Sleep(2000);
//TODO: refactor this dirty hack to wait until actor recovers
foreach (var plan in aggregateActors)
{
CheckAmount(plan.Item2.Aggregate.Amount.Amount, plan.Item1, "write model");
}
}
