internal UnitTestFramework(
ISutCreator sutCreator,
ITellWaiter tellWaiter,
IWaiter childWaiter,
IWaiter exceptionWaiter,
IDependencyResolverAdder resolverAdder,
ITestProbeDependencyResolverAdder testProbeDependencyResolverAdder,
ITestProbeCreator testProbeCreator,
IResolvedTestProbeStore resolvedProbeStore,
ITestProbeChildActorCreator testProbeChildActorCreator,
ITestProbeChildHandlersMapper testProbeChildHandlersMapper,
ISutSupervisorStrategyGetter sutSupervisorStrategyGetter,
ITestProbeParentActorCreator testProbeParentActorCreator,
IDelayer delayer,
ImmutableDictionary <Type, Func <object, object> > parentHandlers,
ImmutableDictionary <(Type, Type), Func <object, object> > childHandlers,
public void Add(
IDependencyResolverAdder dependencyResolverAdder,
ITestProbeChildActorCreator testProbeChildActorCreator,
ITestProbeCreator testProbeCreator,
IResolvedTestProbeStore resolvedTestProbeStore,
IWaiter childWaiter,
TestKitBase testKit,
ImmutableDictionary <Type, ImmutableDictionary <Type, Func <object, object> > > handlers) =>
dependencyResolverAdder.Add(testKit, actorType =>
{
ImmutableDictionary <Type, Func <object, object> > actorHandlers = handlers.GetValueOrDefault(actorType, null);
ITestProbeChildActor probeActor = testProbeChildActorCreator.Create(testProbeCreator, testKit, actorHandlers);
resolvedTestProbeStore.ResolveProbe(probeActor.ActorPath, actorType, probeActor.TestProbe, probeActor.PropsSupervisorStrategy);
childWaiter.ResolveEvent();
return(probeActor.Actor);
});
public TestBase() : base(AkkaConfig.Config)
{
Func <Type> generateType = TestHelper.GetRandomTypeGenerator();
// Create mocks
SutCreatorMock = new Mock <ISutCreator>();
TellWaiterMock = new Mock <ITellWaiter>();
ChildWaiterMock = new Mock <IWaiter>();
ExceptionWaiterMock = new Mock <IWaiter>();
DependencyResolverAdderMock = new Mock <IDependencyResolverAdder>();
TestProbeDependencyResolverAdderMock = new Mock <ITestProbeDependencyResolverAdder>();
ResolvedTestProbeStoreMock = new Mock <IResolvedTestProbeStore>();
TestProbeChildActorCreatorMock = new Mock <ITestProbeChildActorCreator>();
TestProbeCreatorMock = new Mock <ITestProbeCreator>();
TestProbeHandlersMapperMock = new Mock <ITestProbeChildHandlersMapper>();
TestProbeChildActorMock = new Mock <ITestProbeChildActor>();
SutSupervisorStrategyGetterMock = new Mock <ISutSupervisorStrategyGetter>();
TestProbeParentActorCreatorMock = new Mock <ITestProbeParentActorCreator>();
TestProbeParentActorMock = new Mock <ITestProbeParentActor>();
DelayerMock = new Mock <IDelayer>();
// Create objects passed into sut constructor
SutCreator = SutCreatorMock.Object;
TellWaiter = TellWaiterMock.Object;
ChildWaiter = ChildWaiterMock.Object;
ExceptionWaiter = ChildWaiterMock.Object;
DependencyResolverAdder = DependencyResolverAdderMock.Object;
TestProbeDependencyResolverAdder = TestProbeDependencyResolverAdderMock.Object;
TestProbeCreator = TestProbeCreatorMock.Object;
ResolvedTestProbeStore = ResolvedTestProbeStoreMock.Object;
TestProbeChildActorCreator = TestProbeChildActorCreatorMock.Object;
TestProbeHandlersMapper = TestProbeHandlersMapperMock.Object;
SutSupervisorStrategyGetter = SutSupervisorStrategyGetterMock.Object;
TestProbeParentActorCreator = TestProbeParentActorCreatorMock.Object;
Delayer = DelayerMock.Object;
ParentHandlers = ImmutableDictionary <Type, Func <object, object> >
.Empty
.Add((generateType()), message => TestHelper.Generate <object>());
ChildHandlers = ImmutableDictionary <(Type, Type), Func <object, object> >
.Empty
.Add((generateType(), generateType()), message => TestHelper.Generate <object>());
Decider = exception => TestHelper.GenerateEnum <Directive>();
Props = Props.Create <DummyActor>();
PropsWithSupervisorStrategy = Props
.Create <DummyActor>()
.WithSupervisorStrategy(new AllForOneStrategy(
TestHelper.GenerateNumber(),
TestHelper.GenerateNumber(),
exception => TestHelper.Generate <Directive>()));
ExpectedChildCount = TestHelper.GenerateNumber();
ExpectedExceptionCount = TestHelper.GenerateNumber();
// Create objects passed into sut methods
Message = TestHelper.Generate <object>();
ChildName = TestHelper.GenerateString();
ChildNameWithoutSupervisor = TestHelper.GenerateString();
Sender = new Mock <IActorRef>().Object;
DelayDuration = TestHelper.Generate <TimeSpan>();
// Create objects returned by mocks
MappedChildHandlers = ImmutableDictionary <Type, ImmutableDictionary <Type, Func <object, object> > >
.Empty
.Add(generateType(), ImmutableDictionary <Type, Func <object, object> >
.Empty
.Add(generateType(), mess => TestHelper.Generate <object>()));
SutActor = ActorOfAsTestActorRef <DummyActor>();
ResolvedType = generateType();
ResolvedTestProbe = CreateTestProbe();
ResolvedSupervisorStrategy = new AllForOneStrategy(
TestHelper.GenerateNumber(),
TestHelper.GenerateNumber(),
exception => TestHelper.Generate <Directive>());
SutSupervisorStrategy = new OneForOneStrategy(
TestHelper.GenerateNumber(),
TestHelper.GenerateNumber(),
exception => TestHelper.Generate <Directive>());
TestProbeParentActor = TestProbeParentActorMock.Object;
TestProbeParentActorTestProbe = CreateTestProbe();
TestProbeParentActorRef = TestProbeParentActorTestProbe.Ref;
TestProbeParentActorUnhandledExceptions = TestHelper.GenerateMany <Exception>(() => TestHelper.GenerateException());
// Set up mocks
TestProbeParentActorMock
.SetupGet(actor => actor.Ref)
.Returns(TestProbeParentActorRef);
TestProbeParentActorMock
.SetupGet(actor => actor.TestProbe)
.Returns(TestProbeParentActorTestProbe);
TestProbeParentActorMock
.SetupGet(actor => actor.UnhandledExceptions)
.Returns(TestProbeParentActorUnhandledExceptions);
TestProbeParentActorCreatorMock
.SetupSequence(creator => creator.Create(TestProbeCreator, ExceptionWaiter, this, Decider, ParentHandlers))
.Returns(TestProbeParentActor)
.Returns(Mock.Of <ITestProbeParentActor>());
SutCreatorMock
.Setup(creator => creator.Create <DummyActor>(
ChildWaiterMock.Object,
this,
Props,
ExpectedChildCount,
TestProbeParentActorRef))
.Returns(() => SutActor);
ResolvedTestProbeStoreMock
.Setup(store => store.FindResolvedType(SutActor, ChildName))
.Returns(() => ResolvedType);
ResolvedTestProbeStoreMock
.Setup(store => store.FindResolvedTestProbe(SutActor, ChildName))
.Returns(() => ResolvedTestProbe);
ResolvedTestProbeStoreMock
.Setup(store => store.FindResolvedSupervisorStrategy(SutActor, ChildName))
.Returns(() => ResolvedSupervisorStrategy);
ResolvedTestProbeStoreMock
.Setup(store => store.FindResolvedSupervisorStrategy(SutActor, ChildNameWithoutSupervisor))
.Returns(() => null);
TestProbeHandlersMapperMock
.Setup(mapper => mapper.Map(ChildHandlers))
.Returns(() => MappedChildHandlers);
SutSupervisorStrategyGetterMock
.Setup(getter => getter.Get(SutActor.UnderlyingActor))
.Returns(() => SutSupervisorStrategy);
}
public TestBase() : base(AkkaConfig.Config)
{
Func <Type> generateType = TestHelper.GetRandomTypeGenerator();
// Create mocks
DependencyResolverAdderMock = new Mock <IDependencyResolverAdder>();
TestProbeChildActorCreatorMock = new Mock <ITestProbeChildActorCreator>();
TestProbeCreatorMock = new Mock <ITestProbeCreator>();
ResolvedTestProbeStoreMock = new Mock <IResolvedTestProbeStore>();
ChildWaiterMock = new Mock <IWaiter>();
TestProbeChildActorWithHandlersMock = new Mock <ITestProbeChildActor>();
TestProbeChildActorWithoutHandlersMock = new Mock <ITestProbeChildActor>();
// Create objects used by mocks
CallOrder = new List <string>();
// Create objects passed into ActorFactory
ActorWithHandlersType = generateType();
ActorWithoutHandlersType = generateType();
// Create objects passed into sut methods
DependencyResolverAdder = DependencyResolverAdderMock.Object;
TestProbeChildActorCreator = TestProbeChildActorCreatorMock.Object;
TestProbeCreator = TestProbeCreatorMock.Object;
ResolvedTestProbeStore = ResolvedTestProbeStoreMock.Object;
ChildWaiter = ChildWaiterMock.Object;
ActorHandlers = ImmutableDictionary <Type, Func <object, object> >
.Empty
.Add(generateType(), mess => TestHelper.Generate <object>());
Handlers = ImmutableDictionary <Type, ImmutableDictionary <Type, Func <object, object> > >
.Empty
.Add(ActorWithHandlersType, ActorHandlers);
// Create values returned by mocks
ResolvedActorWithHandlers = new Mock <ActorBase>().Object;
ResolvedActorPathWithHandlers = TestHelper.Generate <ActorPath>();
ResolvedTestProbeWithHandlers = CreateTestProbe();
ResolvedSupervisorStrategyWithHandlers = new AllForOneStrategy(
TestHelper.GenerateNumber(),
TestHelper.GenerateNumber(),
exception => TestHelper.Generate <Directive>());
ResolvedActorWithoutHandlers = new Mock <ActorBase>().Object;
ResolvedActorPathWithoutHandlers = TestHelper.Generate <ActorPath>();
ResolvedTestProbeWithoutHandlers = CreateTestProbe();
ResolvedSupervisorStrategyWithoutHandlers = new OneForOneStrategy(
TestHelper.GenerateNumber(),
TestHelper.GenerateNumber(),
exception => TestHelper.Generate <Directive>());
// Set up mocks
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.Actor)
.Returns(() => ResolvedActorWithHandlers);
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.ActorPath)
.Returns(() => ResolvedActorPathWithHandlers);
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.TestProbe)
.Returns(() => ResolvedTestProbeWithHandlers);
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.PropsSupervisorStrategy)
.Returns(() => ResolvedSupervisorStrategyWithHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.Actor)
.Returns(() => ResolvedActorWithoutHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.ActorPath)
.Returns(() => ResolvedActorPathWithoutHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.TestProbe)
.Returns(() => ResolvedTestProbeWithoutHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.PropsSupervisorStrategy)
.Returns(() => ResolvedSupervisorStrategyWithoutHandlers);
TestProbeChildActorCreatorMock
.Setup(creator => creator.Create(TestProbeCreator, this, ActorHandlers))
.Returns(() => TestProbeChildActorWithHandlersMock.Object);
TestProbeChildActorCreatorMock
.Setup(creator => creator.Create(TestProbeCreator, this, null))
.Returns(() => TestProbeChildActorWithoutHandlersMock.Object);
ResolvedTestProbeStoreMock
.Setup(store => store.ResolveProbe(It.IsAny <ActorPath>(), It.IsAny <Type>(), It.IsAny <TestProbe>(), It.IsAny <SupervisorStrategy>()))
.Callback(() => CallOrder.Add(nameof(IResolvedTestProbeStore.ResolveProbe)));
ChildWaiterMock
.Setup(waiter => waiter.ResolveEvent())
.Callback(() => CallOrder.Add(nameof(IWaiter.ResolveEvent)));
DependencyResolverAdderMock
.Setup(adder => adder.Add(this, It.IsAny <Func <Type, ActorBase> >()))
.Callback((TestKitBase testKit, Func <Type, ActorBase> actorFactory) => ActorFactory = actorFactory);
}
