public IActionResult Post(RoverModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.RoverId <= 0)
{
return(BadRequest(Messages.InvalidId));
}
try
{
var rover = RoverFactory.Create(model.RoverId, model.RoverName, 0, 0, Direction.N);
return(Ok(new { RoverId = rover.Id, RoverName = rover.Name }));
}
catch (System.Exception ex)
{
if (ex.Message == "EXISTS")
{
return(Conflict(new ApiResponse
{
Status = 409,
Message = Messages.RoverAlreadyExist
}));
}
else
{
return(StatusCode(500));
}
}
}
public void CreateRoverShouldReturnExpectedType(RoverFactory sut)
{
var actual = sut.CreateRover();
actual.Should().BeOfType <Rover>();
actual.Should().BeAssignableTo <IRover>();
}
public void ParseInputTest()
{
string input = $"5 5{Environment.NewLine}1 2 N{Environment.NewLine}LMLMLMLMM{Environment.NewLine}3 3 E{Environment.NewLine}MMRMMRMRRM{Environment.NewLine}";
string output = string.Empty;
string expectedOutput = $"1 3 N{Environment.NewLine}5 1 E{Environment.NewLine}";
//poor man's dependency injection
IInstructionParser parser = new InstructionParser();
IRoverFactory factory = new RoverFactory();
IRoverService service = new RoverService(factory, parser);
var response = service.ParseInput(new Domain.Parser.Messages.ExecuteRequest()
{
Input = input
});
//if no exceptions encountered
if (response.Exception == null)
{
//get the output
output = response.Output;
}
else
{
output = response.Exception.Message;
}
Console.WriteLine(output);
Assert.AreEqual(expectedOutput, output);
}
public void AddRoverToList(RoverDto roverDto)
{
var plateu = PlateuFactory.CreatePlateu(roverDto.Plateu.CoordinateX, roverDto.Plateu.CoordinateY);
var rover = RoverFactory.CreateRover(roverDto.Id, roverDto.CoordinateX, roverDto.CoordinateY, roverDto.Direction, roverDto.Command, plateu);
rovers.Add(rover);
}
public IActionResult Post(RoverModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.RoverId <= 0)
{
return(BadRequest("Id should be a positive integer value."));
}
try
{
var rover = RoverFactory.Create(model.RoverId, model.RoverName, 0, 0, Direction.N);
return(Ok(new { RoverId = rover.Id, RoverName = rover.Name }));
}
catch (System.Exception ex)
{
if (ex.Message == "EXISTS")
{
return(Conflict(new ApiResponse
{
Status = 409,
Message = "Rover already exists, Cannot be created"
}));
}
else
{
return(StatusCode(500));
}
}
}
public void CreateRover_ReturnsIRover_WhenInputInCorrectFormat(string coordinates)
{
IRover rover = RoverFactory.CreateRover(coordinates, surface.Object);
Assert.NotNull(rover);
Assert.True(rover.X > 0 && rover.Y > 0);
Assert.True(directions.Contains(rover.Direction));
}
private static void Main()
{
var roverFactory = new RoverFactory();
var userIo = new ConsoleUserIO();
var roverManager = new RoverManager(roverFactory);
var missionControl = new MissionControl(roverManager, userIo);
missionControl.StartMission();
}
public IActionResult Put(int roverId, RoverModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var rover = RoverFactory.Update(roverId, model.RoverName);
return(Ok(new { RoverId = rover.Id, RoverName = rover.Name }));
}
public async Task StartRoverOperation()
{
var commandsToExecute = await roverCommandRetriever.GetAll();
EnsureNotEmpty(commandsToExecute);
// Assumption: we are going to operate rovers sequentially
// i.e. the first rover will execute all its commands, then the next and so on...
foreach (var roverCommand in commandsToExecute)
{
if (roverCommand.ManouvreCommands.Any())
{
var rover = RoverFactory.CreateWith(roverCommand);
foreach (var manouvreCommand in roverCommand.ManouvreCommands)
{
// This is not necessarily the prettiest because if NASA asks me to extend
// the capability of the Rover, then I will have to change rover, use case,
// parser and add an extra RoverCommands member. This surface area could be
// reduced by moving the responsbility of instantiating the rover and
// mapping input to rover functions via delegates, into the parser itself
// since each parser will need to determine that for itself anyway. The use
// case will then simply loop over all the commands and execute them one by
// one without having to know which is which (i.e. no switch...case).
// Ofcourse, this only works as long as the commands have a homogenous
// signature and return types. For now though, this will do since we are not
// extending rover behaviour!
CurrentRoverPosition currentRoverPosition = default;
switch (manouvreCommand)
{
case RoverCommands.TurnLeft:
currentRoverPosition = rover.TurnLeft();
break;
case RoverCommands.TurnRight:
currentRoverPosition = rover.TurnRight();
break;
case RoverCommands.Move:
currentRoverPosition = rover.Move();
break;
default:
throw new InvalidOperationException(
$"Rover command {manouvreCommand} is not supported!");
}
await roverPositionTransmitter.Transmit(
currentRoverPosition);
}
}
}
}
public void Test_Move_Rover(int plateuXCoordinate, int plateuYCoordinate, int roverId, int coordinateX, int coordinateY, char direction, string command, int expectedX, int expectedY, Type expectedDirection, bool isOutOfThePlateu)
{
var plateu = PlateuFactory.CreatePlateu(plateuXCoordinate, plateuYCoordinate);
var rover = RoverFactory.CreateRover(roverId, coordinateX, coordinateY, direction, command, plateu);
rover.Move();
Assert.Equal(expectedX, rover.CoordinateX);
Assert.Equal(expectedY, rover.CoordinateY);
Assert.Equal(expectedDirection, rover.Direction.GetType());
Assert.Equal(isOutOfThePlateu, rover.IsOutOfThePlateu);
}
public void Move_ReturnCorrectMovement_WhenMovementIsInSurface()
{
IRover rover = RoverFactory.CreateRover("1 2 N", surface.Object);
rover.Move("M");
rover.Move("R");
rover.Move("M");
Assert.Equal(2, rover.X);
Assert.Equal(3, rover.Y);
Assert.Equal("E", rover.Direction);
}
public void Test_Run_Should_Move_To_51E_When_Given_Input()
{
//Given
RoverRunner roverRunner = new RoverRunner();
roverRunner.Add(RoverFactory.Create(3, 3, 'E', "Rover", new Plateau(5, 5)), "MMRMMRMRRM");
//When
var result = roverRunner.Run();
//Then
Assert.Equal("5 1 E", result[0]);
}
public void Test_Run_Should_Move_To_13N_When_Given_Input()
{
//Given
RoverRunner roverRunner = new RoverRunner();
roverRunner.Add(RoverFactory.Create(1, 2, 'N', "Rover", new Plateau(5, 5)), "LMLMLMLMM");
//When
var result = roverRunner.Run();
//Then
Assert.Equal("1 3 N", result[0]);
}
public void Test_Run_Should_Move_All_Rovers_Sequentially_When_Given_Input()
{
//Given
RoverRunner roverRunner = new RoverRunner();
roverRunner.Add(RoverFactory.Create(1, 2, 'N', "Rover-1", new Plateau(5, 5)), "LMLMLMLMM");
roverRunner.Add(RoverFactory.Create(3, 3, 'E', "Rover-2", new Plateau(5, 5)), "MMRMMRMRRM");
//When
var result = roverRunner.Run();
//Then
Assert.Equal("1 3 N", result[0]);
Assert.Equal("5 1 E", result[1]);
}
public IActionResult GetPosition(int roverId)
{
var rover = RoverFactory.GetRover(roverId);
if (rover == null)
{
return(NotFound());
}
return(Ok(new RoverMoveResponse
{
RoverId = rover.Id,
RoverName = rover.Name,
CurrentX = rover.Position.X,
CurrentY = rover.Position.Y,
CurrentDirection = rover.Position.Direction.ToString()
}));
}
public IActionResult Move(int roverId, RoverMoveModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var rover = RoverFactory.GetRover(roverId);
if (rover == null)
{
throw new RoverException("Rover doesn't exist.");
}
var movements = new List <Movement>();
foreach (var inst in model.MovementInstruction.ToUpper())
{
switch (inst)
{
case 'L':
movements.Add(Movement.Left);
break;
case 'R':
movements.Add(Movement.Right);
break;
case 'M':
movements.Add(Movement.Move);
break;
}
}
rover.Move(movements);
return(Ok(new RoverMoveResponse
{
RoverId = rover.Id,
RoverName = rover.Name,
CurrentX = rover.Position.X,
CurrentY = rover.Position.Y,
CurrentDirection = rover.Position.Direction.ToString()
}));
}
static void Main(string[] args)
{
//Test Input:
//5 5
//1 2 N
//LMLMLMLMM
//3 3 E
//MMRMMRMRRM
//Expected Output:
//1 3 N
//5 1 E
string surf = Console.ReadLine(); //5 5
ISurface surface = SurfaceFactory.CreateSurface(surf);
string rov = Console.ReadLine(); //1 2 N
IRover rover = RoverFactory.CreateRover(rov, surface);
string moves = Console.ReadLine(); //LMLMLMLMM
List <string> movements = MovementFactory.CreateMovement(moves);
foreach (var movement in movements)
{
rover.Move(movement);
}
string rov2 = Console.ReadLine(); //3 3 E
IRover rover2 = RoverFactory.CreateRover(rov2, surface);
string moves2 = Console.ReadLine(); //MMRMMRMRRM
List <string> movements2 = MovementFactory.CreateMovement(moves2);
foreach (var movement2 in movements2)
{
rover2.Move(movement2);
}
Console.WriteLine($"{rover.X} {rover.Y} {rover.Direction}");
Console.WriteLine($"{rover2.X} {rover2.Y} {rover2.Direction}");
Console.ReadLine();
}
public void CreateRover_ThrowsLengthException_WhenInputStringNotHasOnlyTwoSpace(string coordinates)
{
Assert.Throws <ArgumentException>(() => RoverFactory.CreateRover(coordinates, surface.Object));
}
public void CreateRover_ThrowsIntegerTypeException_WhenFirstTwoCharacterHasChar(string coordinates)
{
Assert.Throws <ArgumentException>(() => RoverFactory.CreateRover(coordinates, surface.Object));
}
public void CreateRover_ThrowsDirectionException_WhenThirdCharIsNotaDirection(string coordinates)
{
Assert.Throws <ArgumentException>(() => RoverFactory.CreateRover(coordinates, surface.Object));
}
public void Move_ThrowsMovementCodeInvalidException_WhenMovementCodeIsInvalid(string code)
{
IRover rover = RoverFactory.CreateRover("1 2 N", surface.Object);
Assert.Throws <ArgumentException>(() => rover.Move(code));
}
public void Move_ThrowsRoverIsOurOfRangeException_WhenYCoordinateIsBiggerThanSufaceY()
{
IRover rover = RoverFactory.CreateRover("2 5 N", surface.Object);
Assert.Throws <ArgumentException>(() => rover.Move("M"));
}
public string LandRover(char direction, int x, int y)
{
ActiveRover = RoverFactory.Create(direction, x, y);
return(ActiveRover.Position);
}