예제 #1
0
        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));
        }
        public async Task FilterPerMessage_Work()
        {
            // Arrange
            var log   = new LogBoard <string>();
            var actor = ActorOf(() => new MessageFilterPerMessageActor(log));

            // Act
            actor.Tell("A");
            actor.Tell("B");
            await actor.GracefulStop(TimeSpan.FromMinutes(1), InterfacedPoisonPill.Instance);

            // Assert
            Assert.Equal(
                new[]
            {
                "MessageFilterPerMessageActor.Handle.Constructor",
                "MessageFilterPerMessageActor.Handle.OnPreMessage",
                "Handle(A)",
                "MessageFilterPerMessageActor.Handle.OnPostMessage",
                "MessageFilterPerMessageActor.Handle.Constructor",
                "MessageFilterPerMessageActor.Handle.OnPreMessage",
                "Handle(B)",
                "MessageFilterPerMessageActor.Handle.OnPostMessage",
            },
                log);
        }
        public async Task FilterPerRequest_Work()
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(() => new RequestFilterPerRequestActor(log)).Cast <DummyExRef>();

            // Act
            await a.Call("A");

            await a.Call("B");

            await a.CallEx("C");

            // Assert
            Assert.Equal(
                new[]
            {
                "RequestFilterPerRequestActor.Call.Constructor",
                "RequestFilterPerRequestActor.Call.OnPreRequest",
                "Call(A)",
                "RequestFilterPerRequestActor.Call.OnPostRequest",
                "RequestFilterPerRequestActor.Call.Constructor",
                "RequestFilterPerRequestActor.Call.OnPreRequest",
                "Call(B)",
                "RequestFilterPerRequestActor.Call.OnPostRequest",
                "RequestFilterPerRequestActor.CallEx.Constructor",
                "RequestFilterPerRequestActor.CallEx.OnPreRequest",
                "CallEx(C)",
                "RequestFilterPerRequestActor.CallEx.OnPostRequest"
            },
                log);
        }
        public async Task FilterPerNotification_Work()
        {
            // Arrange
            var log     = new LogBoard <string>();
            var subject = await SetupActors <NotificationFilterPerNotificationActor>(log);

            // Act
            await subject.MakeEvent("A");

            await subject.MakeEvent("B");

            // Assert
            Assert.Equal(
                new[]
            {
                "NotificationFilterPerNotificationActor.Event.Constructor",
                "NotificationFilterPerNotificationActor.Event.OnPreNotification",
                "Event(A)",
                "NotificationFilterPerNotificationActor.Event.OnPostNotification",
                "NotificationFilterPerNotificationActor.Event.Constructor",
                "NotificationFilterPerNotificationActor.Event.OnPreNotification",
                "Event(B)",
                "NotificationFilterPerNotificationActor.Event.OnPostNotification",
            },
                log);
        }
예제 #5
0
        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 MessageFilterPerMessageFilter(string name, object actor)
 {
     if (name != null)
     {
         _name = name;
         LogBoard <string> .Add(actor, $"{_name}.Constructor");
     }
 }
 public NotificationFilterPerNotificationFilter(string name, object actor)
 {
     if (name != null)
     {
         _name = name;
         LogBoard <string> .Add(actor, $"{_name}.Constructor");
     }
 }
 public RequestFilterPerInstanceMethodFilter(string name, object actor)
 {
     if (name != null)
     {
         _name = name;
         LogBoard <string> .Add(actor, $"{_name}.Constructor");
     }
 }
            async Task IPreRequestAsyncFilter.OnPreRequestAsync(PreRequestFilterContext context)
            {
                LogBoard <string> .Add(context.Actor, $"{_actorType.Name} Async.OnPreRequestAsync");

                await Task.Yield();

                LogBoard <string> .Add(context.Actor, $"{_actorType.Name} Async.OnPreRequestAsync Done");
            }
            async Task IPostMessageAsyncFilter.OnPostMessageAsync(PostMessageFilterContext context)
            {
                LogBoard <string> .Add(context.Actor, $"{_actorType.Name} Async.OnPostMessageAsync");

                await Task.Yield();

                LogBoard <string> .Add(context.Actor, $"{_actorType.Name} Async.OnPostMessageAsync Done");
            }
예제 #11
0
        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));
        }
        private async Task <Subject2Ref> SetupActors2 <TObservingActor>(LogBoard <string> log)
            where TObservingActor : ActorBase
        {
            var subjectActor   = ActorOfAsTestActorRef <Subject2Actor>("Subject");
            var subject        = subjectActor.Cast <Subject2Ref>();
            var observingActor = ActorOfAsTestActorRef <TObservingActor>(Props.Create <TObservingActor>(log));
            await subject.Subscribe(new Subject2Observer(new AkkaReceiverNotificationChannel(observingActor)));

            return(subject);
        }
        public async Task BasicCallWithParameter_Done(Type actorType)
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(Props.Create(actorType, log)).Cast <BasicRef>();

            // Act
            await a.CallWithParameter(1);

            // Assert
            Assert.Equal(new[] { "CallWithParameter(1)" }, log);
        }
        public async Task BasicActor_ObserveSubject(object context)
        {
            // Arrange
            var log     = new LogBoard <string>();
            var subject = ActorOf(() => new SubjectExActor()).Cast <SubjectExRef>();
            var a       = ActorOf(() => new TestObserverActor(subject, log)).Cast <DummyRef>();

            // Act
            await a.Call(context);

            // Assert
            Assert.Equal(new[] { "Event:A", "Event:B" }, log);
        }
        public async Task BasicThrowExceptionWithFilter_Done(Type actorType)
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(Props.Create(actorType, log)).Cast <BasicRef>();

            // Act
            var e = await Record.ExceptionAsync(() => a.ThrowException(ThrowExceptionType.ResponsiveByFilter));

            // Assert
            Assert.Equal(new[] { "ThrowException(ResponsiveByFilter)" }, log);
            Assert.IsType <ArgumentException>(e);
        }
        public async Task Mins_Done(Type actorType)
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(Props.Create(actorType, log)).Cast <OverloadedRef>();

            // Act
            var ret = await a.Min(1, 2, 3, 4);

            // Assert
            Assert.Equal(1, ret);
            Assert.Equal(new[] { "Min(1, 2, 3, 4)" }, log);
        }
        public async Task BasicCallWithReturn_Done(Type actorType)
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(Props.Create(actorType, log)).Cast <BasicRef>();

            // Act
            var r = await a.CallWithReturn();

            // Assert
            Assert.Equal(new[] { "CallWithReturn()" }, log);
            Assert.Equal(1, r);
        }
        public async Task GetGenericNotification(Type actorType)
        {
            // Arrange
            var log     = new LogBoard <string>();
            var subject = ActorOf(() => new SubjectActor <string>()).Cast <SubjectRef <string> >();
            var a       = ActorOf(Props.Create(actorType, subject, log)).Cast <DummyRef>();

            // Act
            await a.Call(null);

            // Assert
            Assert.Equal(new[] { $"A", $"B,10" }, log);
        }
예제 #19
0
        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);
        }
예제 #20
0
        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);
        }
예제 #21
0
        public async Task ExceptionThrown_At_Request_With_ResponsiveException()
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(Props.Create(() => new TestExceptionActor(log, 0))).Cast <DummyRef>();

            // Act
            var exception = await Record.ExceptionAsync(() => a.Call("e"));

            // Assert
            Assert.IsType <ArgumentException>(exception);
            Assert.Equal(new[] { "Call(e)" },
                         log);
        }
예제 #22
0
        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);
        }
예제 #23
0
        public void ExceptionThrown_At_HandleAsync()
        {
            // Arrange
            var log   = new LogBoard <string>();
            var actor = ActorOf(Props.Create(() => new TestExceptionActor(log)));

            // Act
            actor.Tell(1);

            // Assert
            Watch(actor);
            ExpectTerminated(actor);
            Assert.Equal(new[] { "HandleAsync(1)" },
                         log);
        }
예제 #24
0
        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 async Task BasicActor_ObserveSubject(object context)
        {
            // Arrange
            var log     = new LogBoard <string>();
            var subject = ActorOf(() => new SubjectActor()).Cast <SubjectRef>();
            var a       = ActorOf(() => new TestObserverActor(subject, log)).Cast <DummyRef>();

            // Act
            await a.Call(context);

            // Assert
            var c = context != null ? context + ":" : "";

            Assert.Equal(new[] { $"{c}A" }, log);
        }
예제 #26
0
        public async Task CallGenericMethod(Type actorType)
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(Props.Create(actorType, log)).Cast <DummyRef <string> >();

            // Act
            var ret1 = await a.Call("A");

            var ret2 = await a.Call("B", 10);

            // Assert
            Assert.Equal("A", ret1);
            Assert.Equal("B", ret2);
            Assert.Equal(new[] { "Call(A)", "Call(B, 10)" }, log);
        }
예제 #27
0
        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);
        }
예제 #28
0
        public async Task ExceptionThrown_At_RequestReentrantAsyncDone()
        {
            // Arrange
            var log = new LogBoard <string>();
            var a   = ActorOf(Props.Create(() => new TestExceptionActor(log, 0))).Cast <WorkerRef>();

            // Act
            var exception = await Record.ExceptionAsync(() => a.Reentrant(2));

            // Assert
            Assert.IsType <RequestFaultException>(exception);
            Watch(a.CastToIActorRef());
            ExpectTerminated(a.CastToIActorRef());
            Assert.Equal(new[] { "Reentrant(2)", "Reentrant(2) Done" },
                         log);
        }
예제 #29
0
        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 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));
        }