// ReSharper disable once VirtualMemberNeverOverriden.Global Init is virtual in order to be mockable
internal virtual void Init(LocalActorRef self)
{
//This might be called directly after the constructor, or when the same actor instance has been returned
//during recreate. In the second case, _self has been set to DeadLetter so we need to set it again.
_self = self;
if (!_hasBeenInitialized) //Do not perform this when "recreating" the same instance
{
_defaultMessageHandler = BuildNewHandler();
_constructorMessageHandlerConfigurators.Pop();
_hasBeenInitialized = true;
}
}
public void When_handling_CreateActor_message_Then_Init_is_called_on_the_new_actor()
{
var mailbox = A.Fake <Mailbox>();
Actor actor = null;
var actorInstantiator = A.Fake <ActorInstantiator>();
//Note: NEVER do this in actual code (returning a premade instance). Always create new instances.
A.CallTo(() => actorInstantiator.CreateNewActor()).ReturnsLazily(() => { actor = A.Fake <Actor>(); return(actor); });
var actorRef = new LocalActorRef(new TestActorSystem(), actorInstantiator, new RootActorPath("test"), mailbox, A.Dummy <InternalActorRef>());
actorRef.HandleSystemMessage(new SystemMessageEnvelope(actorRef, new CreateActor(), A.Fake <ActorRef>()));
A.CallTo(() => actor.Init(actorRef)).MustHaveHappened(Repeated.Exactly.Once);
}
public void When_sending_Then_the_message_is_wrapped_in_an_envelope_and_enqueued_on_the_mailbox()
{
var mailbox = A.Fake <Mailbox>();
var messages = new List <Envelope>();
A.CallTo(() => mailbox.Enqueue(A <Envelope> .Ignored)).Invokes(x => messages.Add(x.GetArgument <Envelope>(0)));
var actorRef = new LocalActorRef(new TestActorSystem(), A.Fake <ActorCreationProperties>(), new RootActorPath("test"), mailbox, A.Dummy <InternalActorRef>());
((InternalActorRef)actorRef).Start();
actorRef.Send("MyTestMessage", null);
messages.Should().Contain(e => e.Message is string && ((string)e.Message) == "MyTestMessage");
}
/// <summary>
/// This one is used for internal testing only
/// </summary>
internal Actor(LocalActorRef actorRef, ActorSystem system, LocalActorRefFactory localActorRefFactory)
{
if (actorRef == null)
{
if (!LocalActorRefStack.TryGetActorRefFromStack(out actorRef))
{
throw new InvalidOperationException(StringFormat.SafeFormat("Cannot create a new instance of type {0} directly using new(). An actor can only be created via the CreateActor methods.", GetType().FullName));
}
LocalActorRefStack.MarkActorRefConsumedInStack();
}
_system = system;
_self = actorRef;
PrepareForConfiguringMessageHandler();
_localActorRefFactory = localActorRefFactory;
}
public async Task Setup()
{
_timeout = TimeSpan.FromMinutes(1);
_system = ActorSystem.Create("system");
_parentActor = _system.ActorOf(Props.Create(() => new ActorWithChild()), "parent");
_localActorRef = (LocalActorRef)await _parentActor.Ask <IActorRef>(_createMessage, _timeout);
_cell = _parentActor.As <ActorRefWithCell>().Underlying.As <ActorCell>();
_repointableActorRef = (RepointableActorRef)_parentActor;
var exp = _system.As <ExtendedActorSystem>();
var vPath = exp.Guardian.Path / "testTemp";
_virtualPathContainer =
new VirtualPathContainer(exp.Provider, vPath, exp.Guardian, exp.Log);
_virtualPathContainer.AddChild("foo",
new EmptyLocalActorRef(exp.Provider, vPath / "foo", exp.EventStream));
}
public void When_handling_CreateActor_message_Then_the_LocalActorRef_is_pushed_to_stack_and_afterwards_removed()
{
var mailbox = A.Fake <Mailbox>();
var actorInstantiator = A.Fake <ActorInstantiator>();
ImmutableStack <LocalActorRef> stackDuringActorCreation = null;
A.CallTo(() => actorInstantiator.CreateNewActor()).Invokes(() =>
{
stackDuringActorCreation = ActorHelper.GetActorRefStack();
}).ReturnsLazily(() => new TestActor());
var actorRef = new LocalActorRef(new TestActorSystem(), actorInstantiator, new RootActorPath("test"), mailbox, A.Dummy <InternalActorRef>());
actorRef.HandleSystemMessage(new SystemMessageEnvelope(actorRef, new CreateActor(), A.Fake <ActorRef>()));
var stackAfterActorCreation = ActorHelper.GetActorRefStack();
stackDuringActorCreation.IsEmpty.Should().BeFalse("The stack should contain one item");
stackDuringActorCreation.Peek().Should().BeSameAs(actorRef, "The item on stack should be the LocalActorRef that creates the actor");
stackDuringActorCreation.Count().Should().Be(1, "The stack should only contain one item.");
(stackAfterActorCreation == null || stackAfterActorCreation.IsEmpty).Should().BeTrue("The stack should be empty after creation");
}
public void When_handling_message_Then_it_is_forwarded_to_the_actor_and_sender_is_set()
{
var mailbox = A.Fake <Mailbox>();
var actor = ActorHelper.CreateActorDirectly <TestActor>();
var actorInstantiator = A.Fake <ActorInstantiator>();
//Note: NEVER do this in actual code (returning a premade instance). Always create new instances.
A.CallTo(() => actorInstantiator.CreateNewActor()).Returns(actor);
var actorRef = new LocalActorRef(new TestActorSystem(), actorInstantiator, new RootActorPath("test"), mailbox, A.Dummy <InternalActorRef>());
var message = new object();
var sender = A.Fake <ActorRef>();
A.CallTo(() => sender.Name).Returns("SenderActor");
//Send Create message so that the instance is created
actorRef.HandleSystemMessage(new SystemMessageEnvelope(actorRef, new CreateActor(), A.Fake <ActorRef>()));
actorRef.HandleMessage(new Envelope(actorRef, message, sender));
actor.ReceivedMessages.Should().HaveCount(1);
actor.ReceivedMessages[0].Item2.Should().BeSameAs(message);
actor.ReceivedMessages[0].Item1.Name.Should().Be("SenderActor");
}
/// <summary>
/// Initializes a new instance of the <see cref="StopChild" /> class.
/// </summary>
/// <param name="child">The child.</param>
public StopChild(LocalActorRef child)
{
Child = child;
}
/// <summary>
/// This will create an actor.
/// <remarks>NOTE! Only use this in tests</remarks>
/// </summary>
public static T CreateActorDirectly <T>(out LocalActorRef localActorRef) where T : Actor, new()
{
return((T)CreateActorDirectly(() => new T(), out localActorRef));
}
