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)); }