public static void Main(string[] args)
{
var roverService = new RoverService(new RoverParser(), new RoverManager());
string fileName = args.FirstOrDefault();
var fileContents = File.ReadAllLines(fileName);
if (string.IsNullOrWhiteSpace(fileName))
{
System.Console.Error.WriteLine("Please enter a file name.");
}
else
{
try
{
roverService.ExecuteInstructions(fileContents);
var headingConverter = new HeadingConverter();
foreach (var rover in roverService.EnumerateRovers())
{
System.Console.WriteLine(string.Format("Rover{0}:{1} {2} {3}", rover.Id, rover.Position.X, rover.Position.Z, headingConverter.ToChar(rover.Heading)));
}
}
catch (Exception ex)
{
System.Console.Error.WriteLine(ex.Message);
}
}
System.Console.Write("Please press any key...");
System.Console.ReadLine();
}
public void Execute_Instruction_Test()
{
var plateauMock = new Mock <IPlateauService>();
plateauMock.Setup(p => p.IsValidPosition(It.IsAny <Position>())).Returns(true);
var leftInstruction = new Mock <IInstruction>();
leftInstruction.Setup(x => x.Execute(It.IsAny <Position>())).Returns(new Position {
X = 1, Y = 3, D = 'N'
});
var instructionFactory = new Mock <IInstructionFactory>();
instructionFactory.Setup(p => p.GetInstruction('L')).Returns(leftInstruction.Object);
var roverService = new RoverService(instructionFactory.Object, plateauMock.Object);
roverService.Deploy("1 3 E", "L");
roverService.ExecuteInstruction();
var rover = roverService.GetRover(0);
Assert.AreEqual(1, rover.Position.X);
Assert.AreEqual(3, rover.Position.Y);
Assert.AreEqual(Direction.North, rover.Position.D);
}
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);
}
/// <summary>
/// save screenshots and other in-outs
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <bool> SaveScreenShotData(RoverEntity input)
{
RoverService service = new RoverService();
var res = await service.SaveData(input);
return(res);
}
/// <summary>
/// get complete history of inouts
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <RoverEntity> > GetAllHistoryInformations()
{
RoverService service = new RoverService();
var res = await service.GetAllDatas();
return(res);
}
public void CreateRoverObject(List <string> inputs)
{
RoverService roverService = new RoverService();
List <Rover> rovers = roverService.GetRoversByInput(inputs);
int expectedRoverCount = (inputs.Count) / 2;
Assert.Equal(expectedRoverCount, rovers.Count);
}
public void Deploy_Direction_Exception()
{
var plateauMock = new Mock <IPlateauService>();
var instructionFactory = new Mock <IInstructionFactory>();
var roverService = new RoverService(instructionFactory.Object, plateauMock.Object);
roverService.Deploy("1 3 P", "LMLMLMLMM");
}
/// <summary>
/// get final points from azure
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <RoverFinalPoints> GetFinalPosFromAzure(RoverInput input)
{
RoverService service = new RoverService();
RoverFinalPoints res = await service.GetFinalPoints(input);
if (res != null && res.FlowPath.Length > 0)
{
return(res);
}
return(null);
}
public void Deploy_Position_Exception()
{
var plateauMock = new Mock <IPlateauService>();
plateauMock.Setup(p => p.IsValidPosition(It.IsAny <Position>())).Returns(false);
var instructionFactory = new Mock <IInstructionFactory>();
var roverService = new RoverService(instructionFactory.Object, plateauMock.Object);
roverService.Deploy("1 3 E", "LMLMLMLMM");
}
public void Process_FirstInput_ReturnExpectedResult()
{
//Arrange
var plateauOne = new Plateau(new Position(5, 5));
var roverService = new RoverService(plateauOne, new Position(1, 2), Directions.N);
//Act
roverService.Process("LMLMLMLMM");
//Assert
var expectedResult = roverService.Print();
expectedResult.Should().Be("1 3 N");
}
public void Process_SecondInput_ReturnExpectedResult()
{
//Arrange
var plateauOne = new Plateau(new Position(5, 5));
var roverService = new RoverService(plateauOne, new Position(3, 3), Directions.E);
//Act
roverService.Process("MMRMMRMRRM");
//Assert
var expectedResult = roverService.Print();
expectedResult.Should().Be("5 1 E");
}
public RoverServiceTest()
{
//Given
_plateauService = new Mock <IPlateauService>();
_loggerMock = new Mock <ILogger <RoverService> >();
_roverService = new RoverService(_loggerMock.Object);
_roverPositionModel = new RoverPositionModel
{
Direction = Direction.North,
X = 1,
Y = 1
};
}
public void Deploy_Test()
{
var plateauMock = new Mock <IPlateauService>();
plateauMock.Setup(p => p.IsValidPosition(It.IsAny <Position>())).Returns(true);
var instructionFactory = new Mock <IInstructionFactory>();
var roverService = new RoverService(instructionFactory.Object, plateauMock.Object);
roverService.Deploy("1 3 E", "LMLMLMLMM");
Assert.AreEqual(1, roverService.rovers.Count);
}
public async void GenerateRoverMovementCommands()
{
string test1 = "20,20 N|LMLMLMM";// test if code handles extremme data
// convert string to stream
byte[] byteArray1 = Encoding.ASCII.GetBytes(test1);
MemoryStream stream = new MemoryStream(byteArray1);
IFileProcessingService fileData = new CsvFileProcessingService(100, 500);
await fileData.ReadFileAsync(stream);
IControlService roverService = new RoverService(fileData.ProcessedRoverData);
roverService.GenerateRoverMovementCommands();
var result = roverService.rovers;
Assert.IsNotNull(result);
}
public void Get_Rover_Test()
{
var plateauMock = new Mock <IPlateauService>();
plateauMock.Setup(p => p.IsValidPosition(It.IsAny <Position>())).Returns(true);
var instructionFactory = new Mock <IInstructionFactory>();
var roverService = new RoverService(instructionFactory.Object, plateauMock.Object);
roverService.Deploy("1 3 E", "LMLMLMLMM");
var rover = roverService.GetRover(0);
Assert.AreEqual(1, rover.Position.X);
Assert.AreEqual(3, rover.Position.Y);
Assert.AreEqual(Direction.East, rover.Position.D);
CollectionAssert.AreEqual("LMLMLMLMM".ToCharArray(), rover.Instruction);
}
public void ChangeDirectionTest()
{
Rover myRover = new Rover();
RoverService roverService = new RoverService();
myRover.X = 1;
myRover.Y = 2;
myRover.Direction = Direction.North;
var response = roverService.ChangeDirection(myRover, 'L');
Assert.AreEqual(myRover.Direction, Direction.West);
Assert.IsNotNull(response);
Assert.IsNotNull(response.IsSuccess);
Assert.IsNotNull(response.Message);
Assert.IsTrue(response.IsSuccess, response.Message);
if (!response.IsSuccess && !string.IsNullOrEmpty(response.Message))
{
Assert.Inconclusive(string.Format("Service success is false. Error Message{0}", response.Message), response.Message);
}
}
public async Task MoveSequence_HitsObsacle_MoveSuccessUntilHit()
{
//Arrange
var fileReaderServiceMock = new Mock <PlanetSurfaceService>();
fileReaderServiceMock.Setup(service => service.GetPlanetLayout()).Returns(() => new int[3, 3] {
{ 0, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
});
var planetService = new PlanetService(fileReaderServiceMock.Object);
var roverService = new RoverService(_loggerMock, planetService);
await roverService.Land(0, 0);
//Act
await roverService.MoveSequence("FLFF");
//Assert
Assert.True(roverService.Position.Item1 == 0 && roverService.Position.Item2 == 1);
}
public async Task MoveSequence_FacesWest_MoveSequenceL()
{
//Arrange
var fileReaderServiceMock = new Mock <PlanetSurfaceService>();
fileReaderServiceMock.Setup(service => service.GetPlanetLayout()).Returns(() => new int[2, 2] {
{ 0, 0 }, { 0, 0 }
});
var planetService = new PlanetService(fileReaderServiceMock.Object);
var roverService = new RoverService(_loggerMock, planetService);
await roverService.Land(0, 0);
//Act
await roverService.MoveSequence("L");
//Assert
Assert.True(roverService.Compass == Models.Compass.E);
}
public async Task MoveSequence_MovesBackward_MoveSequenceS()
{
//Arrange
var fileReaderServiceMock = new Mock <PlanetSurfaceService>();
fileReaderServiceMock.Setup(service => service.GetPlanetLayout()).Returns(() => new int[2, 2] {
{ 0, 0 }, { 0, 0 }
});
var planetService = new PlanetService(fileReaderServiceMock.Object);
var roverService = new RoverService(_loggerMock, planetService);
await roverService.Land(0, 1);
//Act
await roverService.MoveSequence("B");
//Assert
Assert.True(roverService.Position.Item1 == 0 && roverService.Position.Item2 == 0);
}
public async Task <Rover> MoveAsync(MoveParams moveParams)
{
// Get Rover
Rover rover = await GetRoverInfoAsync(moveParams.Id);
if (rover == null)
{
throw new RestException(HttpStatusCode.NotFound,
new { message = $"Rover with id {moveParams.Id} not found." });
}
await using SqliteConnection connection =
new SqliteConnection(_configuration.GetSection("ConnectionStrings:Database").Value);
await connection.OpenAsync();
// Get Planet
Planet planet = await _planetRepository.GetPlanetInfoAsync(rover.PlanetId);
Rover newRover = new Rover
{
Id = rover.Id,
PosX = rover.PosX,
PosY = rover.PosY,
Direction = rover.Direction,
PlanetId = rover.PlanetId
};
SqliteCommand updateRoverPositionCmd = new SqliteCommand
{
Connection = connection,
CommandText = await File.ReadAllTextAsync("../Infrastructure/SQL/Queries/Rover/UpdateRover.sql"),
};
foreach (char instruction in moveParams.Instructions)
{
int prevPosX = newRover.PosX;
int prevPosY = newRover.PosY;
newRover = RoverService.GetNewRoverPosition(planet, newRover, instruction);
// Check if there is an obstacle
if (instruction == RoverDirections.Forward || instruction == RoverDirections.Backward)
{
bool positionHasObstacle =
await _obstacleRepository.PositionHasObstacle(newRover.PosX, newRover.PosY);
if (positionHasObstacle)
{
updateRoverPositionCmd.Parameters.AddRange(
new[]
{
new SqliteParameter
{
ParameterName = "$id",
SqliteType = SqliteType.Integer,
Value = newRover.Id
},
new SqliteParameter
{
ParameterName = "$posX",
SqliteType = SqliteType.Integer,
Value = prevPosX
},
new SqliteParameter
{
ParameterName = "$posY",
SqliteType = SqliteType.Integer,
Value = prevPosY
},
new SqliteParameter
{
ParameterName = "$direction",
SqliteType = SqliteType.Text,
Value = newRover.Direction
}
}
);
await updateRoverPositionCmd.ExecuteNonQueryAsync();
throw new RestException(HttpStatusCode.Forbidden,
new
{
obstacle = new Obstacle
{
PosX = newRover.PosX,
PosY = newRover.PosY
},
rover =
new Rover
{
Id = newRover.Id,
PosX = prevPosX,
PosY = prevPosY,
Direction = newRover.Direction,
PlanetId = newRover.PlanetId
}
});
}
}
}
updateRoverPositionCmd.Parameters.AddRange(
new[]
{
new SqliteParameter
{
ParameterName = "$id",
SqliteType = SqliteType.Integer,
Value = newRover.Id
},
new SqliteParameter
{
ParameterName = "$posX",
SqliteType = SqliteType.Integer,
Value = newRover.PosX
},
new SqliteParameter
{
ParameterName = "$posY",
SqliteType = SqliteType.Integer,
Value = newRover.PosY
},
new SqliteParameter
{
ParameterName = "$direction",
SqliteType = SqliteType.Text,
Value = newRover.Direction
}
}
);
await updateRoverPositionCmd.ExecuteNonQueryAsync();
return(newRover);
}
public void CheckRoverInputData(List <string> inputs)
{
RoverService roverService = new RoverService();
Assert.Throws <InvalidCastException>(() => roverService.GetRoversByInput(inputs));
}
public RoverController(PlanetService planetService, RoverService roverService)
{
_planetService = planetService;
_roverService = roverService;
}
public CalculateRoverMovement()
{
_roverService = new RoverService();
}
public DrawPlateauTest()
{
_roverService = new RoverService();
}
public RoverServiceTest()
{
_mockedInputValidator = new Mock <IInputValidator>();
_sut = new RoverService(_mockedInputValidator.Object);
}
public void If_Given_Invalid_Input_Return_InvalidCastException(List <string> inputs)
{
var roverService = new RoverService();
Assert.Throws <InvalidCastException>(() => roverService.GetRovers(inputs));
}
public void If_Given_Valid_Input_Return_RoverList(List <string> inputs)
{
var roverService = new RoverService();
Assert.NotNull(roverService.GetRovers(inputs));
}
public RoverTest()
{
_plateauService = new PlateauService();
_roverService = new RoverService();
}
public SetRoverOnPlateauTest()
{
_roverService = new RoverService();
}
