public void DeleteTest()
{
// Arrange
var controller = new RoverController();
controller.Post(new CommandBody
{
Command = "5 5",
Type = CommandType.SetupPlateau
});
controller.Post(new CommandBody
{
Command = "1 2 N",
Type = CommandType.SetupRover
});
controller.Post(new CommandBody
{
Command = "LMLMLMLMM",
Type = CommandType.Move
});
var beforeCount = controller.Get().Count;
// Act
controller.Delete();
var afterCount = controller.Get().Count;
// Assert
Assert.IsTrue(beforeCount > 0, "Before count should be more than zero");
Assert.AreEqual(0, afterCount);
}
private RoverController CreateRoverController()
{
var plateau = new Plateau(10, 10);
var controller = new RoverController(plateau);
return(controller);
}
public void ShouldMoveRoversCorrectly()
{
Stream stream = null;
try
{
stream = new MemoryStream();
using (StreamWriter writer = new StreamWriter(stream))
{
stream = null;
writer.WriteLine("5 5");
writer.WriteLine("1 2 N");
writer.WriteLine("LMLMLMLMM");
writer.WriteLine("3 3 E");
writer.WriteLine("MMRMMRMRRM");
writer.Flush();
writer.BaseStream.Position = 0;
var controller = new RoverController(writer.BaseStream);
var result = controller.RoverPositions();
result.ShouldEqual("1 3 N\r\n5 1 E\r\n");
}
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
}
public void SquadShouldBeAbleToSendMoreThanOneRovers()
{
//Arrange
var command = new Command();
command.Rovers = new List <RoverCommand>();
command.Plateau = ("5 5");
command.Rovers.Add(new RoverCommand {
Position = ("1 2 N"), Movement = ("LMLMLMLMM")
});
command.Rovers.Add(new RoverCommand {
Position = ("3 3 E"), Movement = ("MMRMMRMRRM")
});
var squad = new Squad(_rover);
var logger = new Mock <ILogger <RoverController> >();
var controller = new RoverController(logger.Object, squad, _helper);
//Act
var rovers = (List <string>)controller.SendCommands(command);
//Assert
Assert.AreEqual("1 3 N", rovers[0]);
Assert.AreEqual("5 1 E", rovers[1]);
}
static void Main(string[] args)
{
IPlato marsPlato = new Plato(new Coordinate(5, 5));
Rover rover1 = new Rover(new Coordinate(1, 2), Direction.N);
var rover1Controller = new RoverController(rover1, marsPlato);
Rover rover2 = new Rover(new Coordinate(3, 3), Direction.E);
var rover2Controller = new RoverController(rover2, marsPlato);
rover1Controller.SetCommand("LMLMLMLMM");
rover2Controller.SetCommand("MMRMMRMRRM");
var roverSquad = new RoverSquad();
roverSquad.AddRover(rover1Controller);
roverSquad.AddRover(rover2Controller);
foreach (var rover in roverSquad.Rovers)
{
roverSquad.ExecuteRover(rover);
Console.WriteLine(rover.GetPosition());
}
Console.ReadLine();
}
public void ProcessInput_CommandSequence_ReturnsCorrectPosition(string input, string expected)
{
var rover = new RoverController();
var actual = rover.ProcessInput(input);
Assert.Equal(expected, actual);
}
public void PostTestSetupPlateau()
{
// Arrange
var controller = new RoverController();
controller.Delete();
int plateauX = 5;
int plateauY = 5;
int plateauX2 = 24;
int plateauY2 = 13;
string expected = "0 0 -> 5 5";
string expected2 = "0 0 -> 24 13";
// Act
var result = controller.Post(new CommandBody
{
Command = $"{plateauX} {plateauY}",
Type = CommandType.SetupPlateau
});
var result2 = controller.Post(new CommandBody
{
Command = $"{plateauX2} {plateauY2}",
Type = CommandType.SetupPlateau
});
// Assert
Assert.AreEqual(expected, result);
Assert.AreEqual(expected2, result2);
}
public IController Connect(IConnection connection, Map map)
{
// connection pooling to reconnect to previously used connections.
var existngConn = _connections
.Find(c => c.Position.CompareTo(connection.InitialPosition) == 0);
if (existngConn != null)
{
return(existngConn);
}
var x = connection.InitialPosition.X;
var y = connection.InitialPosition.Y;
var dir = connection.Direction;
IController ctrl;
switch (connection.Entity)
{
case ConnectionTypes.Rover:
ctrl = new RoverController(new Position(x, y), dir, map);
_connections.Add(ctrl);
break;
default:
throw new InvalidConnectionException();
}
return(ctrl);
}
public void Return_Success_Result_For_Given_Rover()
{
// Arrange
List <RoverRequest> roverInfoReq = new List <RoverRequest>
{
new RoverRequest {
Name = "Rover1", Instructions = "MRM"
}
};
List <RoverResponse> roverInfoResp = new List <RoverResponse>
{
new RoverResponse {
Name = "Rover1", NewPositions = new int[] { 2, 1 }, Message = "Success"
}
};
var robotCreator = new Mock <IRobotCreator>();
robotCreator.Setup(repo => repo.CreateAndMoveRobots(roverInfoReq, new int[5, 5])).Returns(roverInfoResp);
var sut = new RoverController(robotCreator.Object);
//Act
var result = sut.Post(roverInfoReq);
//Assert
Assert.IsNotNull(result);
var okResult = result as OkObjectResult;
Assert.IsNotNull(okResult);
Assert.IsInstanceOfType(result, typeof(IActionResult));
}
public void ProcessInput_InvalidPlateauSize_ReportsError(string input, string expected)
{
var rover = new RoverController();
var actual = rover.ProcessInput(input);
Assert.Equal(actual, expected);
}
public void PostTestSetupRover()
{
// Arrange
var controller = new RoverController();
controller.Delete();
Rover rover1 = new Rover(1, 2, 'N');
Rover rover2 = new Rover(3, 3, 'E');
// Act
var result1 = controller.Post(new CommandBody
{
Command = rover1.ToString(),
Type = CommandType.SetupRover
});
var result2 = controller.Post(new CommandBody
{
Command = rover2.ToString(),
Type = CommandType.SetupRover
});
// Assert
Assert.AreEqual(rover1.ToString(), result1);
Assert.AreEqual(rover2.ToString(), result2);
}
public void ProcessInput_RoverLeavesGrid_ReturnsWrappedPosition(string input, string expected)
{
var rover = new RoverController();
var actual = rover.ProcessInput(input);
Assert.Equal(expected, actual);
}
public void ProcessInput_ParseOriginAndTurnLeft_ReturnsCorrectPosition(string input, string expected)
{
var rover = new RoverController();
var actual = rover.ProcessInput(input);
Assert.Equal(expected, actual);
}
public void RotateTest_WhenDirectionInvalid_ShouldThrow()
{
var rotateDirection = 'N';
var orientation = Orientation.West;
Assert.ThrowsException <InvalidRotationArgumentException>(() => RoverController.Rotate(rotateDirection, orientation));
}
public void UpperRightCoordinates_UpperRightCoordinatesWithInvalidSyntaxY_ShouldThrowFormatException()
{
var upperRightCoordinates = "10 H";
var rover = new RoverController();
Assert.ThrowsException <System.FormatException>(() => rover.UpperRightCoordinates = upperRightCoordinates);
}
public void UpperRightCoordinates_WithYUpperRightCoordinateGreaterThan30_ShouldThrowArgumentOutOfRangeException()
{
var upperRightCoordinates = "15 40";
var rover = new RoverController();
Assert.ThrowsException <System.ArgumentOutOfRangeException>(() => rover.UpperRightCoordinates = upperRightCoordinates);
}
public void UpperRightCoordinates_WithXUpperRightCoordinateLessThan1_ShouldThrowArgumentOutOfRangeException()
{
var upperRightCoordinates = "0 15";
var rover = new RoverController();
Assert.ThrowsException <System.ArgumentOutOfRangeException>(() => rover.UpperRightCoordinates = upperRightCoordinates);
}
public void BeFalseWhenAnyCommandIsOutBounds()
{
RoverController controller = new RoverController(new Size(2, 2), new Coordinates(0, 0), CardinalPoint.North);
Commands[] commands = new[] { Commands.A, Commands.A, Commands.A };
Assert.False(controller.Handle(commands));
}
public void TestWrongInstructions()
{
string instructions = "5 5\r\n1 2 N\r\nLMMMMMMMMM\r\n3 3 E\r\nMMRMMRMRRM";
var roverController = new RoverController(instructions);
string result = roverController.Action();
Assert.IsTrue(result.Contains("invalid instructions"));
}
public void BeTrueWhenAllCommandsIsInBounds()
{
RoverController controller = new RoverController(new Size(10, 10), new Coordinates(0, 0), CardinalPoint.North);
Commands[] commands = new[] { Commands.A, Commands.A, Commands.A };
Assert.True(controller.Handle(commands));
}
public void ExecuteMovementPlan_WhenMovementIsOutOfBounds_ShouldThrow()
{
var plateau = new Plateau(new Coordinate(5, 5));
var rover = new Rover("1 2 E", plateau);
var movementPlan = "MMMMMM";
Assert.ThrowsException <InvalidMovementException>(() => RoverController.ExecuteMovementPlan(movementPlan, rover, plateau));
}
public void ParseOrientation_WhenPassedValidDirection_ShouldParse()
{
var coord = "1 4 N";
var expected = Orientation.North;
var actual = RoverController.ParseOrientation(coord);
Assert.AreEqual(expected, actual);
}
public void ParseCoordinate_WhenPassedValidString_ShouldParse()
{
var coord = "1 4 N";
var expected = new Coordinate(1, 4);
var actual = RoverController.ParseCoordinate(coord);
Assert.AreEqual(expected, actual);
}
public void Given_Command_Then_RoverIsDeployedToCorrectLocation(string deployCommand, int expectedMapX, int expectedMapY, int expectedStartX, int expectedStartY, string expectedOrientation)
{
var rover = MockRepository.GenerateStub <IRover>();
var roverController = new RoverController(rover);
roverController.DeployRover(deployCommand);
rover.AssertWasCalled(r => r.Land(Arg <Map> .Matches(m => m.X == expectedMapX && m.Y == expectedMapY), Arg <int> .Is.Equal(expectedStartX), Arg <int> .Is.Equal(expectedStartY), Arg <CompassPoint> .Is.Equal(ParseCompassPoint(expectedOrientation))));
}
public void GetAllRoversTest()
{
List <Rover> testRovers = DataContext.Rovers;
RoverController controller = new RoverController();
List <Rover> result = controller.Get() as List <Rover>;
Assert.AreEqual(testRovers.Count, result.Count);
}
public void RotateTest_WhenDirectionValid_ShouldRotate()
{
var rotateDirection = 'L';
var orientation = Orientation.North;
var expected = Orientation.West;
var actual = RoverController.Rotate(rotateDirection, orientation);
Assert.AreEqual(expected, actual);
}
public void TestOutOfBoundsPosition_Negative()
{
RoverController rc = new RoverController
{
NorthEastBound = new Tuple <int, int>(3, 3)
};
Assert.IsFalse(rc.IsInBounds(new Tuple <int, int>(-1, 3)));
}
public void TestInBoundsPosition()
{
RoverController rc = new RoverController
{
NorthEastBound = new Tuple <int, int>(3, 3)
};
Assert.IsTrue(rc.IsInBounds(new Tuple <int, int>(1, 3)));
}
public void DeployThrowsRoverDeploymentException3()
{
Action action = () => RoverController.GetRoverController().Deploy(
new Plateau(new Coordinate(3, 3)),
"2 2 A"
);
Assert.Throws <RoverDeploymentException>(action);
}
public void TestHappyPathInstructions()
{
string instructions = "5 5\r\n1 2 N\r\nLMLMLMLMM\r\n3 3 E\r\nMMRMMRMRRM";
var roverController = new RoverController(instructions);
string result = roverController.Action();
Assert.AreEqual(
"1 3 N\r\n5 1 E", result);
}
public void IncreaseYWhenAdvanceToNorth()
{
RoverController controller = new RoverController(new Size(2, 2), new Coordinates(0, 0), CardinalPoint.North);
Commands[] commands = new[] { Commands.A };
controller.Handle(commands);
Assert.Equal(new Coordinates(0, 1), controller.CurrentCoordinates);
}
