public void TestConstructorFailure()
{
World.ActorFor <IParentInterface>(Definition.Has <ParentInterfaceActor>(Definition.NoParameters));
var address = World.AddressFactory.UniqueWith("test-actor-ctor-failure");
var definition = Definition.Has <FailureActor>(
Definition.Parameters("test-ctor-failure", -100),
ParentInterfaceActor.Instance.Value,
address.Name);
var mailbox = new TestMailbox();
Assert.Throws <ArgumentException>(() => ActorFactory.ActorFor(
World.Stage,
definition.Parent,
definition,
address,
mailbox,
null,
World.DefaultLogger));
}
public void TestActorForWithParameters()
{
World.ActorFor <IParentInterface>(Definition.Has <ParentInterfaceActor>(Definition.NoParameters));
var actorName = "test-child";
var definition =
Definition.Has <TestInterfaceWithParamsActor>(
Definition.Parameters("test-text", 100),
ParentInterfaceActor.Instance.Value,
actorName);
var address = World.AddressFactory.UniqueWith(actorName);
var mailbox = new TestMailbox();
var actor =
ActorFactory.ActorFor(
World.Stage,
definition.Parent,
definition,
address,
mailbox,
null,
World.DefaultLogger);
Assert.NotNull(actor);
Assert.NotNull(actor.Stage);
Assert.Equal(World.Stage, actor.Stage);
Assert.NotNull(actor.LifeCycle.Environment.Parent);
Assert.Equal(ParentInterfaceActor.Instance.Value, actor.LifeCycle.Environment.Parent);
Assert.NotNull(actor.LifeCycle.Environment);
Assert.NotNull(actor.LifeCycle.Environment.Definition);
Assert.Equal(definition, actor.LifeCycle.Environment.Definition);
Assert.NotNull(actor.LifeCycle.Environment.Address);
Assert.Equal(address, actor.LifeCycle.Environment.Address);
Assert.NotNull(actor.LifeCycle.Environment.Mailbox);
Assert.Equal(mailbox, actor.LifeCycle.Environment.Mailbox);
}
public void Given_Middleware_Should_Call_In_Order_Then_Actor()
{
var logs = new List <string>();
var testMailbox = new TestMailbox();
var props = Actor.FromFunc(c =>
{
if (c.Message is string)
{
logs.Add("actor");
}
return(Actor.Done);
})
.WithMiddleware(
next => async c =>
{
if (c.Message is string)
{
logs.Add("middleware 1");
}
await next(c);
},
next => async c =>
{
if (c.Message is string)
{
logs.Add("middleware 2");
}
await next(c);
})
.WithMailbox(() => testMailbox);
var pid = Actor.Spawn(props);
pid.Tell("");
Assert.Equal(3, logs.Count);
Assert.Equal("middleware 1", logs[0]);
Assert.Equal("middleware 2", logs[1]);
Assert.Equal("actor", logs[2]);
}
public void Given_ReceiveMiddleware_Should_Call_Middleware_In_Order_Then_Actor_Receive()
{
var logs = new List <string>();
var testMailbox = new TestMailbox();
var props = Props.FromFunc(c =>
{
if (c.Message is string)
{
logs.Add("actor");
}
return(Actor.Done);
})
.WithReceiveMiddleware(
next => async(c, env) =>
{
if (env.Message is string)
{
logs.Add("middleware 1");
}
await next(c, env);
},
next => async(c, env) =>
{
if (env.Message is string)
{
logs.Add("middleware 2");
}
await next(c, env);
})
.WithMailbox(() => testMailbox);
var pid = Context.Spawn(props);
Context.Send(pid, "");
Assert.Equal(3, logs.Count);
Assert.Equal("middleware 1", logs[0]);
Assert.Equal("middleware 2", logs[1]);
Assert.Equal("actor", logs[2]);
}
public void TestExecute()
{
var testResults = new TestResults(Total, false);
var mailbox = new TestMailbox(testResults, World.DefaultLogger);
var actor = new CountTakerActor(testResults, World.DefaultLogger);
for (var count = 0; count < Total; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
dispatcher.Execute(mailbox);
}
List <int> counts = testResults.GetCounts();
Assert.Equal(Total, counts.Count);
for (var idx = 0; idx < counts.Count; ++idx)
{
Assert.Contains(idx, counts);
}
}
public void Given_ContextDecorator_Should_Call_Decorator_Before_Actor_Receive()
{
var logs = new List <string>();
var logs2 = new List <string>();
var logs3 = new List <string>();
var testMailbox = new TestMailbox();
var props = Props.FromFunc(c =>
{
switch (c.Message)
{
//only inspect "decorator" message
case string str when str == "decorator":
logs.Add("actor");
return(Actor.Done);
default:
return(Actor.Done);
}
})
.WithMailbox(() => testMailbox)
.WithContextDecorator(c => new TestContextDecorator(c, logs), c => new TestContextDecorator(c, logs2))
.WithContextDecorator(c => new TestContextDecorator(c, logs3));
var pid = Context.Spawn(props);
Context.Send(pid, "middleware");
Assert.Equal(2, logs.Count);
Assert.Equal("decorator", logs[0]);
Assert.Equal("actor", logs[1]);
foreach (var log in new[] { logs2, logs3 })
{
Assert.Single(log);
Assert.Equal("decorator", log[0]);
}
}
