public void PostElevatorDestination_ShouldEnqueueProperCommand()
        {
            //Arrange
            var elevatorId    = _fixture.Create <int>();
            var destinationId = _fixture.Create <int>();

            string           resultQueueId = string.Empty;
            GoToFloorCommand resultAction  = null;

            _elevatorMessagePublisher
            .Setup(s => s.EnqueueRequest(It.IsAny <string>(), It.IsAny <GoToFloorCommand>()))
            .Callback <string, GoToFloorCommand>((id, action) =>
            {
                resultQueueId = id;
                resultAction  = action;
            });

            //Act
            _sut.EnqueueElevatorDestination(elevatorId, destinationId);

            //Assert
            resultQueueId.Should().Be(ElevatorsMessagingHelper.GetQueueId(elevatorId));
            resultAction.Should().NotBeNull();
            resultAction.ElevatorId.Should().Be(elevatorId);
            resultAction.DestinationFloorId.Should().Be(destinationId);
            resultAction.ActionType.Should().Be(ElevatorCommandType.GoToFloor);
        }
Esempio n. 2
0
 private static void AddGoToFloorCommands(SkyscraperDto skyscraperDto, Queue <int> queue, ElevatorCommands elevatorCommands, bool jumpQueue)
 {
     if (queue.Count > 0)
     {
         var destination      = queue.Dequeue();
         var goToFloorCommand = new GoToFloorCommand(skyscraperDto.EventRaisedElevatorIndex, destination, jumpQueue);
         elevatorCommands.GoToFloors.Enqueue(goToFloorCommand);
     }
 }
        public void EnqueueElevatorDestination(int elevatorId, int floorId)
        {
            _elevatorsValidationHelper.ValidateElevatorId(elevatorId);
            _elevatorsValidationHelper.ValidateFloorId(floorId);

            var action = new GoToFloorCommand
            {
                DestinationFloorId = floorId,
                ElevatorId         = elevatorId
            };

            _elevatorMessagePublisher.EnqueueRequest(ElevatorsMessagingHelper.GetQueueId(elevatorId), action);
        }
        private async Task GoToFloor(GoToFloorCommand goToFloorCommand)
        {
            var elevator = await _aggregateRepository.LoadAsync <Elevator>(goToFloorCommand.ElevatorId);

            if (!elevator.DoorClosed)
            {
                await CloseDoors(goToFloorCommand.ElevatorId);

                await _aggregateRepository.SaveAsync(elevator);

                elevator = await _aggregateRepository.LoadAsync <Elevator>(goToFloorCommand.ElevatorId);
            }

            elevator.SetDestination(goToFloorCommand.DestinationFloorId);

            await _aggregateRepository.SaveAsync(elevator);

            elevator = await _aggregateRepository.LoadAsync <Elevator>(goToFloorCommand.ElevatorId);

            if (goToFloorCommand.DestinationFloorId != elevator.CurrentFloor)
            {
                if (goToFloorCommand.DestinationFloorId < elevator.CurrentFloor)
                {
                    for (; goToFloorCommand.DestinationFloorId < elevator.CurrentFloor;)
                    {
                        Thread.Sleep(1000);
                        elevator.GoDown();
                        await _aggregateRepository.SaveAsync(elevator);

                        elevator = await _aggregateRepository.LoadAsync <Elevator>(goToFloorCommand.ElevatorId);
                    }
                }
                else
                {
                    for (; goToFloorCommand.DestinationFloorId > elevator.CurrentFloor;)
                    {
                        Thread.Sleep(1000);
                        elevator.GoUp();
                        await _aggregateRepository.SaveAsync(elevator);

                        elevator = await _aggregateRepository.LoadAsync <Elevator>(goToFloorCommand.ElevatorId);
                    }
                }
            }

            await OpenDoors(goToFloorCommand.ElevatorId);

            await _aggregateRepository.SaveAsync(elevator);
        }