public async Task GetInterfacedPoisonPill_WaitForAllReentrantHandlersDone()
{
// Arrange
var log = new LogBoard<string>();
var a = ActorOf(() => new TestGracefulShutdownActor(log)).Cast<WorkerRef>();
// Act
a.WithNoReply().Reentrant(1);
a.WithNoReply().Reentrant(2);
await a.CastToIActorRef().GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);
// Assert
Assert.True(new HashSet<string>
{
"Reentrant(1)",
"Reentrant(1) done",
"Reentrant(2)",
"Reentrant(2) done",
}.SetEquals(log.Take(4)));
Assert.Equal(new List<string>
{
"OnGracefulStop",
"OnGracefulStop done"
}, log.Skip(4));
}
private async Task<Tuple<Subject2Ref, IActorRef>> SetupActors2(LogBoard<string> log)
{
var subjectActor = ActorOfAsTestActorRef<Subject2Actor>("Subject");
var subject = subjectActor.Cast<Subject2Ref>();
var observingActor = ActorOf(() => new TestExceptionActor(log));
await subject.Subscribe(new Subject2Observer(new AkkaReceiverNotificationChannel(observingActor)));
return Tuple.Create(subject, (IActorRef)observingActor);
}
public void DisplayLogboard()
{
logBoard.SetActive(true);
LogBoard lb = logBoard.GetComponent <LogBoard>();
lb.ClearRecords();
List <ActionEventInfo> events = Logger.GetLoggedEvents();
for (var i = events.Count - 1; i >= 0; i--)
{
lb.AddRecord(events[i]);
}
}
public async Task Message_SyncHandler_ExecutedSequantially()
{
// Arrange
var log = new LogBoard<string>();
var actor = ActorOf(() => new TestMessageActor(log));
// Act
actor.Tell(new PlainMessages.Func { Value = "A" });
await actor.GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);
// Assert
Assert.Equal(new[] { "A_1" },
log);
}
public async Task TaskRun_SyncHandler_ExecutedSequantially()
{
// Arrange
var log = new LogBoard<string>();
var actor = ActorOf(() => new TestRunActor(log));
// Act
actor.Tell("S:1");
await actor.GracefulStop(TimeSpan.FromMinutes(1), "X");
// Assert
Assert.Equal(new[] { "S:1" },
log);
}
public async Task StopActor_RunningAsyncRequestHandler_Canceled()
{
var log = new LogBoard<string>();
var worker = ActorOf(() => new TaskCancellationActor(log, 100)).Cast<WorkerRef>();
var exceptionTask = Record.ExceptionAsync(() => worker.Reentrant(1));
worker.CastToIActorRef().Tell("E");
Assert.IsType<RequestHaltException>(await exceptionTask);
Watch(worker.CastToIActorRef());
ExpectTerminated(worker.CastToIActorRef());
await Task.Delay(100);
Assert.Equal(new[] { "Reentrant(1)" }, log);
}
public void ExceptionThrown_At_Handle()
{
// Arrange
var log = new LogBoard<string>();
var actor = ActorOf(Props.Create(() => new TestExceptionActor(log)));
// Act
actor.Tell("E");
// Assert
Watch(actor);
ExpectTerminated(actor);
Assert.Equal(new[] { "Handle(E)" },
log);
}
public async Task Schedule_ReentrantHandler_Interleaved()
{
// Arrange
var log = new LogBoard<Tuple<int, int>>();
var a = ActorOf(() => new TestScheduleActor(log)).Cast<WorkerRef>();
// Act
var t1 = a.Reentrant(1);
var t2 = a.Reentrant(2);
await Task.WhenAll(t1, t2);
// Assert
Assert.Equal(new[] { 1, 2, 3 },
log.Where(t => t.Item1 == 1).Select(t => t.Item2));
Assert.Equal(new[] { 1, 2, 3 },
log.Where(t => t.Item1 == 1).Select(t => t.Item2));
}
public void ExceptionThrown_At_PreStart()
{
var log = new LogBoard <string>();
var actor = ActorOf(Props.Create(() => new TestExceptionActor(log, "PreStart")));
actor.Tell("");
Watch(actor);
ExpectTerminated(actor);
Assert.Equal(
new[]
{
"ctor",
"PreStart",
},
log);
}
public async Task FilterPerClass_Work()
{
// Arrange
var log = new LogBoard<string>();
var a = ActorOf(() => new RequestFilterPerClassActor(log)).Cast<DummyRef>();
// Act
await a.Call("A");
// Assert
Assert.Equal(
new[]
{
"RequestFilterPerClassActor.OnPreRequest",
"Call(A)",
"RequestFilterPerClassActor.OnPostRequest"
},
log);
}
public async Task FilterPerClass_Work()
{
// Arrange
var log = new LogBoard<string>();
var actor = ActorOf(() => new MessageFilterPerClassActor(log));
// Act
actor.Tell("A");
await actor.GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);
// Assert
Assert.Equal(
new[]
{
"MessageFilterPerClassActor.OnPreMessage",
"Handle(A)",
"MessageFilterPerClassActor.OnPostMessage"
},
log);
}
public async Task StartEvent_Order()
{
var log = new LogBoard<string>();
var actor = ActorOf(Props.Create(() => new TestStartActor(log)));
actor.Tell("A");
await actor.GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);
Watch(actor);
ExpectTerminated(actor);
Assert.Equal(
new[]
{
"PreStart()",
"OnStart(False) Begin",
"OnStart(False) End",
"Handle(A) Begin",
"Handle(A) End",
},
log);
}
public void ExceptionThrown_At_OnGracefulStop()
{
var log = new LogBoard <string>();
var actor = ActorOf(Props.Create(() => new TestExceptionActor(log, "OnGracefulStop")));
actor.Tell(InterfacedPoisonPill.Instance);
Watch(actor);
ExpectTerminated(actor);
Assert.Equal(
new[]
{
"ctor",
"PreStart",
"OnStart",
"OnStart Done",
"OnGracefulStop",
"PostStop"
},
log);
}
public void ExceptionThrown_At_MessageHandle()
{
var log = new LogBoard <string>();
var actor = ActorOf(Props.Create(() => new TestExceptionActor(log, null)));
actor.Tell("E");
Watch(actor);
ExpectTerminated(actor);
Assert.Equal(
new[]
{
"ctor",
"PreStart",
"OnStart",
"OnStart Done",
"Handle(E)",
"PostStop"
},
log);
}
public async Task StartEvent_Order()
{
var log = new LogBoard <string>();
var actor = ActorOf(Props.Create(() => new TestStartActor(log)));
actor.Tell("A");
await actor.GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);
Watch(actor);
ExpectTerminated(actor);
Assert.Equal(
new[]
{
"PreStart()",
"OnStart(False) Begin",
"OnStart(False) End",
"Handle(A) Begin",
"Handle(A) End",
},
log);
}
public async Task Schedule_AtomicHandler_Sequential()
{
// Arrange
var log = new LogBoard<Tuple<int, int>>();
var a = ActorOf(() => new TestScheduleActor(log)).Cast<WorkerRef>();
// Act
var t1 = a.Atomic(1);
var t2 = a.Atomic(2);
await Task.WhenAll(t1, t2);
// Assert
Assert.Equal(new Tuple<int, int>[]
{
Tuple.Create(1, 1),
Tuple.Create(1, 2),
Tuple.Create(1, 3),
Tuple.Create(2, 1),
Tuple.Create(2, 2),
Tuple.Create(2, 3),
}, log);
}
public async Task GetInterfacedPoisonPill_WaitForAllAtomicHandlersDone()
{
// Arrange
var log = new LogBoard<string>();
var a = ActorOf(() => new TestGracefulShutdownActor(log)).Cast<WorkerRef>();
// Act
a.WithNoReply().Atomic(1);
a.WithNoReply().Atomic(2);
await a.CastToIActorRef().GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);
// Assert
Assert.Equal(new List<string>
{
"Atomic(1)",
"Atomic(1) done",
"Atomic(2)",
"Atomic(2) done",
"OnGracefulStop",
"OnGracefulStop done"
}, log);
}
public MessageFilterPerInstanceMethodActor(LogBoard<string> log)
{
_log = log;
}
public async Task TaskRun_AtomicAsyncHandler_ExecutedInterleaved()
{
// Arrange
var log = new LogBoard<string>();
var actor = ActorOf(() => new TestRunActor(log));
// Act
actor.Tell("R:1");
actor.Tell("R:2");
await actor.GracefulStop(TimeSpan.FromMinutes(1), "X");
// Assert
Assert.Equal(new[] { "R:1", "R:2" },
log.Take(2));
Assert.Equal(new[] { "R:1 done", "R:2 done" },
log.Skip(2).OrderBy(x => x));
}
public async Task Dispatch_ReentrantHandlers_KeepContext()
{
// Arrange
var log = new LogBoard<Tuple<int, object>>();
var a = ActorOf(() => new TestContextActor(log)).Cast<WorkerRef>();
// Act
var t1 = a.Reentrant(1);
var t2 = a.Reentrant(2);
await Task.WhenAll(t1, t2);
// Assetr
var logs = log;
Assert.Equal(1, logs.Where(t => t.Item1 == 1).Select(t => t.Item2).Distinct().Count());
Assert.Equal(1, logs.Where(t => t.Item1 == 1).Select(t => t.Item2).Distinct().Count());
Assert.Equal(2, logs.Select(t => t.Item2).Distinct().Count());
}
public TestRunActor(LogBoard<string> log)
{
_log = log;
}
public TestMessageActor(LogBoard<string> log)
{
_log = log;
}
public TestFilterActor(LogBoard<string> log)
{
_log = log;
}
public async Task StopActor_RunningAsyncMessageHandler_Canceled()
{
var log = new LogBoard<string>();
var worker = ActorOf(() => new TaskCancellationActor(log, 100)).Cast<WorkerRef>();
worker.CastToIActorRef().Tell(1);
worker.CastToIActorRef().Tell("E");
Watch(worker.CastToIActorRef());
ExpectTerminated(worker.CastToIActorRef());
await Task.Delay(100);
Assert.Equal(new[] { "Handle(1)" }, log);
}
public TestScheduleActor(LogBoard<Tuple<int, int>> log)
{
_log = log;
}
public async Task ExceptionThrown_At_Notification()
{
// Arrange
var log = new LogBoard<string>();
var actors = await SetupActors(log);
// Act
await actors.Item1.MakeEvent("E");
// Assert
Watch(actors.Item2);
ExpectTerminated(actors.Item2);
Assert.Equal(new[] { "Event(E)" },
log);
}
public TestStartActor(LogBoard <string> log)
{
_log = log;
}
public MessageFilterPerClassActor(LogBoard<string> log)
{
_log = log;
}
public RequestFilterPerClassActor(LogBoard<string> log)
{
_log = log;
}
public TestContextActor(LogBoard<Tuple<int, object>> log)
{
_log = log;
}
public TestExceptionActor(LogBoard<string> log)
{
_log = log;
}
public TaskCancellationActor(LogBoard<string> log, int delay)
{
_log = log;
_delay = delay;
}
public async Task FilterOrder_Work()
{
// Arrange
var log = new LogBoard<string>();
var subject = ActorOf(() => new SubjectActor()).Cast<SubjectRef>();
var observingActor = ActorOf(() => new TestFilterActor(log));
await subject.Subscribe(new SubjectObserver(new AkkaReceiverNotificationChannel(observingActor)));
// Act
await subject.MakeEvent("A");
await Task.Delay(10);
// Assert
Assert.Equal(
new[]
{
"TestFilterActor_1.OnPreNotification",
"TestFilterActor_2.OnPreNotification",
"Event(A)",
"TestFilterActor_2.OnPostNotification",
"TestFilterActor_1.OnPostNotification"
},
log);
}
public async Task StopActor_RunningAsyncNotificationHandler_Canceled()
{
var log = new LogBoard<string>();
var subjectActor = ActorOfAsTestActorRef<SubjectActor>("Subject");
var subject = subjectActor.Cast<SubjectRef>();
var observingActor = ActorOf(() => new TaskCancellationActor(log, 100));
await subject.Subscribe(new SubjectObserver(new AkkaReceiverNotificationChannel(observingActor)));
await subject.MakeEvent("E");
observingActor.Tell("E");
Watch(observingActor);
ExpectTerminated(observingActor);
await Task.Delay(100);
Assert.Equal(new[] { "Event(E)" }, log);
}
public TestExceptionActor(LogBoard <string> log, string tag = null)
{
_log = log;
_tag = tag;
_log.Add("ctor");
}
public async Task ExceptionThrown_At_NotificationReentrantAsyncDone()
{
// Arrange
var log = new LogBoard<string>();
var actors = await SetupActors2(log);
// Act
await actors.Item1.MakeEvent2("F");
// Assert
Watch(actors.Item2);
ExpectTerminated(actors.Item2);
Assert.Equal(new[] { "Event2(F)", "Event2(F) Done" },
log);
}
public async Task Message_AtomicAsyncHandler_ExecutedInterleaved()
{
// Arrange
var log = new LogBoard<string>();
var actor = ActorOf(() => new TestMessageActor(log));
// Act
actor.Tell(new PlainMessages.TaskReentrant { Value = "A" });
actor.Tell(new PlainMessages.TaskReentrant { Value = "B" });
await actor.GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);
// Assert
Assert.Equal(new[] { "A_1", "B_1" },
log.Take(2));
Assert.Equal(new[] { "A_2", "B_2" },
log.Skip(2).OrderBy(x => x));
}
