Example #1
0
        public async Task UpdateAsyncTest_SectorFiresTransition_GlobeTransitionHandlersInitiatesTransitions()
        {
            // ARRANGE

            var transitionHandlerMock = new Mock <IGlobeTransitionHandler>();
            var transitionHandler     = transitionHandlerMock.Object;

            var globe = new Globe(transitionHandler);

            var sectorNodeMock = new Mock <ISectorNode>();

            sectorNodeMock.SetupGet(x => x.State).Returns(SectorNodeState.SectorMaterialized);
            var sectorNode = sectorNodeMock.Object;

            var transitionNode = Mock.Of <IGraphNode>();

            var sectorMock = new Mock <ISector>();

            sectorMock.SetupGet(x => x.Map)
            .Returns(Mock.Of <ISectorMap>(map =>
                                          map.Transitions == new Dictionary <IGraphNode, SectorTransition>
            {
                { transitionNode, new SectorTransition(Mock.Of <ISectorNode>()) }
            }
                                          ));
            var sector = sectorMock.Object;

            sectorNodeMock.SetupGet(x => x.Sector).Returns(sector);

            var actorMock = new Mock <IActor>();

            actorMock.SetupGet(x => x.Person).Returns(Mock.Of <IPerson>(person => person.Id == 0));
            actorMock.SetupGet(x => x.CanExecuteTasks).Returns(true);
            actorMock.SetupGet(x => x.Node).Returns(transitionNode);
            var actor = actorMock.Object;

            var taskSourceMock    = new Mock <IActorTaskSource <ISectorTaskSourceContext> >();
            var taskSource        = taskSourceMock.Object;
            var taskSourceContext = Mock.Of <ISectorTaskSourceContext>(context => context.Sector == sector);
            var taskContext       = Mock.Of <IActorTaskContext>(taskContext => taskContext.Sector == taskSourceContext.Sector);

            taskSourceMock.Setup(x => x.GetActorTaskAsync(It.IsAny <IActor>(), It.IsAny <ISectorTaskSourceContext>()))
            .Returns <IActor, ISectorTaskSourceContext>((actor, context) =>
                                                        Task.FromResult((IActorTask) new SectorTransitTask(actor, taskContext)));

            actorMock.SetupGet(x => x.TaskSource).Returns(taskSource);

            var actorManagerMock = new Mock <IActorManager>();
            var actorManager     = actorManagerMock.Object;

            actorManagerMock.SetupGet(x => x.Items).Returns(new[] { actor });
            sectorMock.SetupGet(x => x.ActorManager).Returns(actorManager);

            globe.AddSectorNode(sectorNode);

            // ACT

            for (var i = 0; i < GlobeMetrics.OneIterationLength; i++)
            {
                await globe.UpdateAsync(CancellationToken.None).ConfigureAwait(false);
            }

            // ASSERT

            actorMock.Verify(x => x.MoveToOtherSector(It.Is <ISector>(s => s == sector), It.IsAny <SectorTransition>()),
                             Times.Once);
        }