public async Task GetPlanetByIdCheckResponseTypeTest()
{
//Arrange
var mockPlanetRepository = new Mock <IPlanetRepository>();
mockPlanetRepository.Setup(s => s.GetByIdAsync(Guid.Parse("37bb3789-894a-432a-b9c2-8c9602dfa0c7")))
.Returns(GetPlanetForTest());
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(s => s.Map <Task <Planet> >(GetPlanetForTest()))
.Returns(GetPlanetForTest());
var mockSwApiConnector = new Mock <ISwApiConnector>();
mockSwApiConnector.Setup(s => s.GetAllMovieApparitionsByPlanet("Planet 4"))
.Returns(1);
var controller = new PlanetsController(mockPlanetRepository.Object, mockSwApiConnector.Object, mockMapper.Object);
//Act
var response = await controller.GetPlanetById(Guid.Parse("37bb3789-894a-432a-b9c2-8c9602dfa0c7"));
//Assert
Assert.IsType <ObjectResult>(response);
}
public void saveCurrent()
{
byte[] bytesToEncode = Encoding.UTF8.GetBytes(PlanetsController.getAllBodyFields());
string encodedText = Convert.ToBase64String(bytesToEncode);
Debug.Log(encodedText);
}
public void CreatePost_WithExistingPlanetName_ShouldReturnView()
{
// Arrange
Mock <IPlanetService> planetService = new Mock <IPlanetService>();
planetService
.Setup(s => s.Exists(It.IsAny <string>()))
.Returns(true);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
string errorMessage = null;
tempData
.SetupSet(t => t[WebConstants.TempDataErrorMessage] = It.IsAny <string>())
.Callback((string key, object message) => errorMessage = message as string);
PlanetFormServiceModel formModel = this.GetPlanetFormModel();
PlanetsController planetsController = new PlanetsController(planetService.Object);
planetsController.TempData = tempData.Object;
// Act
IActionResult result = planetsController.Create(1, formModel);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PlanetFormServiceModel>(model);
PlanetFormServiceModel returnModel = model as PlanetFormServiceModel;
this.AssertPlanets(formModel, returnModel);
Assert.Equal(string.Format(WebConstants.EntryExists, Planet), errorMessage);
}
public async Task GetAllPlanetsCheckResponseTypeTest()
{
//Arrange
var mockPlanetRepository = new Mock <IPlanetRepository>();
mockPlanetRepository.Setup(s => s.GetAllAsync())
.Returns(GetPlanetsForTest());
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(s => s.Map <Task <IEnumerable <PlanetForGetViewModel> > >(GetPlanetsForGetTest()))
.Returns(GetPlanetsForGetTest());
var mockSwApiConnector = new Mock <ISwApiConnector>();
mockSwApiConnector.Setup(s => s.GetAllMovieApparitionsByPlanet("Planet 1"))
.Returns(1);
var controller = new PlanetsController(mockPlanetRepository.Object, mockSwApiConnector.Object, mockMapper.Object);
//Act
var response = await controller.GetAllPlanets();
//Assert
Assert.IsType <ObjectResult>(response.Result);
}
// Update is called once per frame
void Update()
{
if (PlanetsController.followMassCenter)
{
gameObject.transform.position = PlanetsController.getMassCenter();
}
else if (PlanetsController.follow != null && PlanetsController.running)
{
gameObject.transform.position = new Vector3(PlanetsController.follow.gameObject.transform.position.x, PlanetsController.follow.gameObject.transform.position.y, -10f);
}
else
{
//gameObject.transform.position = new Vector3(0f, 0f, -10f);
}
if (Input.GetAxis("Horizontal") > 0f || Input.GetAxis("Vertical") > 0f)
{
PlanetsController.follow = null;
PlanetsController.MassCenterToggle.isOn = false;
PlanetsController.followMassCenter = false;
}
gameObject.transform.position += new Vector3(Input.GetAxis("Horizontal") * Time.deltaTime * PlanetsController.camDist, Input.GetAxis("Vertical") * Time.deltaTime * PlanetsController.camDist, 0f);
if (Input.GetKey(KeyCode.Minus) && PlanetsController.camDist < 15f && PlanetsController.canZoom)
{
PlanetsController.camDist += 0.05f;
}
if (Input.GetKey(KeyCode.Equals) && PlanetsController.camDist > 2f && PlanetsController.canZoom)
{
PlanetsController.camDist -= 0.05f;
}
GetComponent <Camera>().orthographicSize = PlanetsController.camDist;
}
public void EditPost_WithNotSuccessfullEdit_ShouldReturnBadRequest()
{
// Arranges
Mock <IPlanetService> planetService = new Mock <IPlanetService>();
PlanetFormServiceModel formModel = this.GetPlanetFormModel();
planetService
.Setup(s => s.Exists(It.IsAny <string>()))
.Returns(false);
planetService
.Setup(s => s.GetName(It.IsAny <int>()))
.Returns(formModel.Name);
planetService
.Setup(s => s.Edit(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <int>()))
.Returns(false);
PlanetsController planetsController = new PlanetsController(planetService.Object);
// Act
IActionResult result = planetsController.Edit(1, 1, formModel);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void DeletePost_WithSuccessfullDelete_ShouldReturnRedirectResult()
{
// Arranges
Mock <IPlanetService> planetService = new Mock <IPlanetService>();
planetService
.Setup(s => s.Delete(It.IsAny <int>()))
.Returns(true);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
string successmessage = null;
tempData
.SetupSet(t => t[WebConstants.TempDataSuccessMessage] = It.IsAny <string>())
.Callback((string key, object message) => successmessage = message as string);
PlanetsController planetsController = new PlanetsController(planetService.Object);
planetsController.TempData = tempData.Object;
const int discoveryId = 1;
// Act
IActionResult result = planetsController.DeletePost(1, discoveryId);
// Assert
Assert.IsType <RedirectToActionResult>(result);
RedirectToActionResult redirectResult = result as RedirectToActionResult;
this.AssertRedirect(discoveryId, redirectResult);
Assert.Equal(string.Format(WebConstants.SuccessfullEntityOperation, Planet, WebConstants.Deleted), successmessage);
}
public void EditGet_WithExistingId_ShouldReturnView()
{
// Arrange
Mock <IPlanetService> planetService = new Mock <IPlanetService>();
PlanetFormServiceModel formModel = this.GetPlanetFormModel();
planetService
.Setup(s => s.GetForm(It.IsAny <int>()))
.Returns(formModel);
PlanetsController planetsController = new PlanetsController(planetService.Object);
// Act
IActionResult result = planetsController.Edit(1, 1);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PlanetFormServiceModel>(model);
PlanetFormServiceModel returnModel = model as PlanetFormServiceModel;
this.AssertPlanets(formModel, returnModel);
}
void OnMouseDown()
{
offset = gameObject.transform.position - Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0f));
PlanetsController.selectedBody = this.gameObject;
PlanetsController.updateFields();
drag = true;
}
public void GetPlanetByNameCheckResponseTypeTest()
{
//Arrange
var mockPlanetRepository = new Mock <IPlanetRepository>();
mockPlanetRepository.Setup(s => s.GetByNameAsync("Planet 4"))
.Returns(GetPlanetNotTaskForTest());
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(s => s.Map <Task <Planet> >(GetPlanetForTest()))
.Returns(GetPlanetForTest());
var mockSwApiConnector = new Mock <ISwApiConnector>();
mockSwApiConnector.Setup(s => s.GetAllMovieApparitionsByPlanet("Planet 4"))
.Returns(1);
var controller = new PlanetsController(mockPlanetRepository.Object, mockSwApiConnector.Object, mockMapper.Object);
//Act
var response = controller.GetPlanetByName("Planet 4");
//Assert
Assert.IsType <ObjectResult>(response);
}
public void GetPlanet_ShouldReturnCorrectDistanceFromSun()
{
var testPlanet = GetTestPlanets();
var controller = new PlanetsController(testPlanet);
var result = controller.Get("Mercury") as OkNegotiatedContentResult<Planet>;
Assert.IsNotNull(result);
Assert.AreEqual(testPlanet[0].DistanceFromSun, result.Content.DistanceFromSun);
}
public void GetAllPlanets_ShouldReturnAllPlanets()
{
var testPlanets = GetTestPlanets();
var controller = new PlanetsController();
var result = controller.GetPlanets() as List <Planet>;
Assert.AreEqual(testPlanets.Count, result.Count);
}
public PlanetTest()
{
AutoMapper.Mapper.Initialize(cfg =>
{
cfg.CreateMap <Planet, PlanetListDto>();
});
_planetsServiceMock = new Mock <IPlanetService>();
_sut = new PlanetsController(_planetsServiceMock.Object);
}
public void GetPlanet_ShouldReturnCorrectDistanceFromSun()
{
var testPlanet = GetTestPlanets();
var controller = new PlanetsController(testPlanet);
var result = controller.Get("Mercury") as OkNegotiatedContentResult <Planet>;
Assert.IsNotNull(result);
Assert.AreEqual(testPlanet[0].DistanceFromSun, result.Content.DistanceFromSun);
}
public void CreateGet_ShouldReturnView()
{
// Arrange
PlanetsController planetsController = new PlanetsController(null);
// Act
IActionResult result = planetsController.Create();
// Assert
Assert.IsType <ViewResult>(result);
}
// Update is called once per frame
void Update()
{
if (PlanetsController.resetEqualsCurrent())
{
this.gameObject.GetComponent <Text>().text = "Clear All";
}
else
{
this.gameObject.GetComponent <Text>().text = "Reset";
}
}
void OnMouseDrag()
{
if (!PlanetsController.running && PlanetsController.selectedBody == this.gameObject)
{
Vector3 curScreenPoint = new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0f);
PlanetsController.updateFields();
Vector3 curPosition = Camera.main.ScreenToWorldPoint(curScreenPoint) + offset;
curPosition.z = 0f;
rigidbody.position = curPosition; gameObject.transform.position = curPosition;
}
}
public async Task ShouldReturnSuccessfullMessageWhenRemovePlanet(int id)
{
//Arrange
var mockRepo = new Mock <IPlanetApplicationService>();
mockRepo.Setup(repo => repo.RemovePlanet(id)).ReturnsAsync(true);
var controller = new PlanetsController(mockRepo.Object, _mapper);
//Act
var result = await controller.Delete(id);
//Assert
var objectResult = Assert.IsType <OkObjectResult>(result);
var strResponse = Assert.IsAssignableFrom <string>(objectResult.Value);
Assert.Equal("Planet was successfull deleted!", strResponse);
}
public async Task ShoudReturn4Planets()
{
//Arrange
var mockRepo = new Mock <IPlanetApplicationService>();
mockRepo.Setup(repo => repo.GetAllPlanets()).ReturnsAsync(StarWarsMockCore.GetAllPlanets());
var controller = new PlanetsController(mockRepo.Object, _mapper);
//Act
var result = await controller.Get();
//Assert
var objectResult = Assert.IsType <ObjectResult>(result);
var model = Assert.IsAssignableFrom <List <PlanetViewModel> >(objectResult.Value);
Assert.Equal(4, model.Count());
}
public async Task ShoudReturnPlanetByName(string name)
{
//Arrange
var mockRepo = new Mock <IPlanetApplicationService>();
mockRepo.Setup(repo => repo.GetPlanetByName(name)).ReturnsAsync(StarWarsMockCore.GetPlanetOK);
var controller = new PlanetsController(mockRepo.Object, _mapper);
//Act
var result = await controller.Get(name);
//Assert
var objectResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <PlanetViewModel>(objectResult.Value);
Assert.Equal("Planet Test", model.Name);
}
public void DeletePost_WithNotSuccessfullDelete_ShouldReturnBadRequest()
{
// Arranges
Mock <IPlanetService> planetService = new Mock <IPlanetService>();
planetService
.Setup(s => s.Delete(It.IsAny <int>()))
.Returns(false);
PlanetsController planetsController = new PlanetsController(planetService.Object);
// Act
IActionResult result = planetsController.DeletePost(1, 1);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void Then_All_Planets_Are_Returned()
{
//Arrange
const string testplanetA = "TestPlanetA";
const string testplanetB = "TestPlanetB";
const int testplanetDistanceA = 5;
const int testplanetDistanceB = 15;
IEnumerable <Planet> testPlanets = new[]
{
new Planet
{
Name = testplanetA,
DistanceToSun = testplanetDistanceA
},
new Planet
{
Name = testplanetB,
DistanceToSun = testplanetDistanceB
}
};
const int expectedPlanetCount = 2;
var mockPlanetRepo = new Mock <IPlanetRepository>();
mockPlanetRepo.Setup(x => x.GetAllPlanets()).Returns(testPlanets);
var controller = new PlanetsController(mockPlanetRepo.Object);
// Act
var result = controller.GetPlanets();
var planets = result as IList <Planet> ?? result.ToList();
// Assert
Assert.IsNotNull(planets, "GetPlanets should not return Null");
Assert.AreEqual(expectedPlanetCount, planets.Count, String.Format("GetPlanets should have returned {0} planets", expectedPlanetCount));
Assert.AreEqual(planets[0].Name, testplanetA, String.Format("GetPlanets should return {0} as the first planet's name", testplanetA));
Assert.AreEqual(planets[0].DistanceToSun, testplanetDistanceA, String.Format("GetPlanets should return {0} as the first planet's distance to the sun", testplanetA));
Assert.AreEqual(planets[1].Name, testplanetB, String.Format("GetPlanets should return {0} as the second planet's name", testplanetB));
Assert.AreEqual(planets[1].DistanceToSun, testplanetDistanceB, String.Format("GetPlanets should return {0} as the second planet's distance to the sun", testplanetB));
}
public void EditGet_WithNotExistingId_ShouldReturnBadRequest()
{
// Arrange
Mock <IPlanetService> planetService = new Mock <IPlanetService>();
PlanetFormServiceModel model = null;
planetService
.Setup(s => s.GetForm(It.IsAny <int>()))
.Returns(model);
PlanetsController planetsController = new PlanetsController(planetService.Object);
// Act
IActionResult result = planetsController.Edit(1, 1);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public async Task ShouldReturnSuccessfullMessageWhenCreatePlanet(int id, string name, string climate, string terrain, int appearances)
{
//Arrange
var planet = new Planet()
{
Id = id, Name = name, Climate = climate, Terrain = terrain, AppearanceInMovies = appearances
};
var mockRepo = new Mock <IPlanetApplicationService>();
mockRepo.Setup(repo => repo.CreatePlanet(planet)).ReturnsAsync(true);
var controller = new PlanetsController(mockRepo.Object, _mapper);
//Act
var result = await controller.Post(planet);
//Assert
var objectResult = Assert.IsType <OkObjectResult>(result);
var strResponse = Assert.IsAssignableFrom <string>(objectResult.Value);
Assert.Equal("Planet successfull created!", strResponse);
}
public PlanetTest()
{
_planetContext = new PlanetContext();
var unitOfWork = new UnitOfWork(_planetContext);
_planetService = new PlanetService(unitOfWork);
_planetsController = new PlanetsController(_planetService);
_planets = new List <Planet>
{
new Planet {
Name = "Mercury", Distance = 57910000, PlanetId = Guid.Empty
},
new Planet {
Name = "Venus", Distance = 108200000, PlanetId = Guid.Empty
},
new Planet {
Name = "Earth", Distance = 149600000, PlanetId = Guid.Empty
},
new Planet {
Name = "Mars", Distance = 227940000, PlanetId = Guid.Empty
},
new Planet {
Name = "Jupiter", Distance = 778330000, PlanetId = Guid.Empty
},
new Planet {
Name = "Saturn", Distance = 1424600000, PlanetId = Guid.Empty
},
new Planet {
Name = "Uranus", Distance = 2873550000, PlanetId = Guid.Empty
},
new Planet {
Name = "Neptune", Distance = 4501000000, PlanetId = Guid.Empty
},
new Planet {
Name = "Pluto", Distance = 5945900000, PlanetId = Guid.Empty
}
};
}
public void CreatePost_WithNotSuccessfullyCreatedPlanet_ShouldReturnBadRequest()
{
// Arrange
Mock <IPlanetService> planetService = new Mock <IPlanetService>();
planetService
.Setup(s => s.Exists(It.IsAny <string>()))
.Returns(false);
planetService
.Setup(s => s.Create(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <int>()))
.Returns(false);
PlanetsController planetsController = new PlanetsController(planetService.Object);
planetsController.TempData = Mock.Of <ITempDataDictionary>();
PlanetFormServiceModel formModel = this.GetPlanetFormModel();
// Act
IActionResult result = planetsController.Create(1, formModel);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void goToMassCenter()
{
gameObject.transform.position = PlanetsController.getMassCenter();
}
private static IActionResult GetPlanet(string planetName)
{
var planetsController = new PlanetsController(new TestsServiceFactory());
return(planetsController.Get(planetName));
}
private static void GetAll()
{
var planetsController = new PlanetsController(new TestsServiceFactory());
_result = planetsController.Get();
}
// Update is called once per frame
void Update()
{
button.interactable = !PlanetsController.resetEqualsCurrent();
}
