public void CheckFunctionDelete() { // Add an initial League object to the database prior to deleting League league = new League(); league.LeagueId = 1; league.Year = "2007"; databaseContext.League.Add(league); databaseContext.SaveChanges(); // Count the number of leagues in the database var preCountTask = databaseContext.League.CountAsync(); preCountTask.Wait(); int preCount = preCountTask.Result; // Create the controller and call the Create method LeaguesController controller = new LeaguesController(databaseContext); var resultTask = controller.DeleteConfirmed(1); resultTask.Wait(); IActionResult result = resultTask.Result as IActionResult; // Count the number of leagues in the database after the change var postCountTask = databaseContext.League.CountAsync(); postCountTask.Wait(); int postCount = postCountTask.Result; // Check that there is one more league in the database than what was // in it previous to the Create method call Assert.AreEqual(preCount - 1, postCount); }
public async Task PutLeague_WhenLeagueIsNotFound_ShouldReturnNotFoundResult() { // Arrange var leagueRepository = A.Fake <ILeagueRepository>(); League?league = null; A.CallTo(() => leagueRepository.GetLeagueAsync(A <int> .Ignored)).Returns(league); var sharedRepository = A.Fake <ISharedRepository>(); var mapper = A.Fake <IMapper>(); var linkGenerator = A.Fake <LinkGenerator>(); var testController = new LeaguesController(leagueRepository, sharedRepository, mapper, linkGenerator); int id = 1; var model = new LeagueModel(); // Act var result = await testController.PutLeague(id, model); // Assert A.CallTo(() => leagueRepository.GetLeagueAsync(id)).MustHaveHappenedOnceExactly(); result.Result.ShouldBeOfType <NotFoundObjectResult>(); ((NotFoundObjectResult)result.Result).Value.ShouldBe($"Could not find league with ID of {id}"); }
public void CheckFunctionCreate() { // Count the number of leagues in the database var preCountTask = databaseContext.League.CountAsync(); preCountTask.Wait(); int preCount = preCountTask.Result; // Create the controller and call the Create method LeaguesController controller = new LeaguesController(databaseContext); League league = new League(); league.Year = "2007"; var resultTask = controller.Create(league); resultTask.Wait(); IActionResult result = resultTask.Result as IActionResult; // Count the number of leagues in the database after the change var postCountTask = databaseContext.League.CountAsync(); postCountTask.Wait(); int postCount = postCountTask.Result; // Check that there is one more league in the database than what was // in it previous to the Create method call Assert.AreEqual(preCount + 1, postCount); }
public async Task GetLeague_WhenLeagueIsNotNull_ShouldReturnLeagueModelOfDesiredLeague() { // Arrange var leagueRepository = A.Fake <ILeagueRepository>(); League?league = new League(); A.CallTo(() => leagueRepository.GetLeagueAsync(A <int> .Ignored)).Returns(league); var sharedRepository = A.Fake <ISharedRepository>(); var mapper = A.Fake <IMapper>(); LeagueModel?leagueModel = new LeagueModel(); A.CallTo(() => mapper.Map <LeagueModel>(A <League> .Ignored)).Returns(leagueModel); var linkGenerator = A.Fake <LinkGenerator>(); var testController = new LeaguesController(leagueRepository, sharedRepository, mapper, linkGenerator); int id = 1; // Act var result = await testController.GetLeague(id); // Assert A.CallTo(() => leagueRepository.GetLeagueAsync(id)).MustHaveHappenedOnceExactly(); A.CallTo(() => mapper.Map <LeagueModel>(league)).MustHaveHappenedOnceExactly(); result.Value.ShouldBeOfType <LeagueModel>(); }
public async Task DeleteLeague_WhenLeagueIsFoundAndNotDeleted_ShouldReturnBadRequest() { // Arrange var leagueRepository = A.Fake <ILeagueRepository>(); League?league = new League(); A.CallTo(() => leagueRepository.GetLeagueAsync(A <int> .Ignored)).Returns(league); var sharedRepository = A.Fake <ISharedRepository>(); A.CallTo(() => sharedRepository.SaveChangesAsync()).Returns(0); var mapper = A.Fake <IMapper>(); var linkGenerator = A.Fake <LinkGenerator>(); var testController = new LeaguesController(leagueRepository, sharedRepository, mapper, linkGenerator); int id = 1; // Act var result = await testController.DeleteLeague(id); // Assert A.CallTo(() => leagueRepository.GetLeagueAsync(id)).MustHaveHappenedOnceExactly(); A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly(); result.Result.ShouldBeOfType <BadRequestResult>(); }
public async Task Details_WhenIdIsNotNullAndLeagueFound_ShouldReturnLeagueDetailsView() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); League?league = new League(); A.CallTo(() => leagueRepository.GetLeagueAsync(A <int> .Ignored)).Returns(league); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); int?id = 0; // Act var result = await testController.Details(id); // Assert A.CallTo(() => leagueRepository.GetLeagueAsync(id.Value)).MustHaveHappenedOnceExactly(); leaguesDetailsViewModel.League.ShouldBe(league); result.ShouldBeOfType <ViewResult>(); ((ViewResult)result).Model.ShouldBe(leaguesDetailsViewModel); }
public async Task EditPost_WhenIdEqualsLeagueIdAndModelStateIsNotValid_ShouldReturnLeagueEditView() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); int id = 1; var league = new League { ID = 1 }; testController.ModelState.AddModelError("LongName", "Please enter a long name."); // Act var result = await testController.Edit(id, league); // Assert A.CallTo(() => leagueRepository.Update(A <League> .Ignored)).MustNotHaveHappened(); A.CallTo(() => sharedRepository.SaveChangesAsync()).MustNotHaveHappened(); result.ShouldBeOfType <ViewResult>(); ((ViewResult)result).Model.ShouldBe(league); }
public async Task GetLeague_WhenExceptionIsCaught_ShouldReturnInternalServerError() { // Arrange var leagueRepository = A.Fake <ILeagueRepository>(); League?league = new League(); A.CallTo(() => leagueRepository.GetLeagueAsync(A <int> .Ignored)).Throws <Exception>(); var sharedRepository = A.Fake <ISharedRepository>(); var mapper = A.Fake <IMapper>(); LeagueModel?leagueModel = new LeagueModel(); A.CallTo(() => mapper.Map <LeagueModel>(A <League> .Ignored)).Returns(leagueModel); var linkGenerator = A.Fake <LinkGenerator>(); var testController = new LeaguesController(leagueRepository, sharedRepository, mapper, linkGenerator); int id = 1; // Act var result = await testController.GetLeague(id); // Assert result.Result.ShouldBeOfType <ObjectResult>(); ((ObjectResult)result.Result).StatusCode.ShouldBe(StatusCodes.Status500InternalServerError); ((ObjectResult)result.Result).Value.ShouldBe("Database failure"); }
public async Task EditPost_WhenIdEqualsLeagueIdAndModelStateIsValidAndDbUpdateConcurrencyExceptionIsCaughtAndLeagueWithIdDoesNotExist_ShouldReturnNotFound() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); A.CallTo(() => leagueRepository.Update(A <League> .Ignored)).Throws <DbUpdateConcurrencyException>(); A.CallTo(() => leagueRepository.LeagueExists(A <int> .Ignored)).Returns(false); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); int id = 1; var league = new League { ID = 1 }; // Act var result = await testController.Edit(id, league); // Assert result.ShouldBeOfType <NotFoundResult>(); }
public async Task EditPost_WhenIdEqualsLeagueIdAndModelStateIsValidAndDbUpdateConcurrencyExceptionIsCaughtAndLeagueWithIdExists_ShouldRethrowException() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); A.CallTo(() => leagueRepository.Update(A <League> .Ignored)).Throws <DbUpdateConcurrencyException>(); A.CallTo(() => leagueRepository.LeagueExists(A <int> .Ignored)).Returns(true); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); int id = 1; var league = new League { ID = 1 }; // Act var func = new Func <Task <IActionResult> >(async() => await testController.Edit(id, league)); // Assert await func.ShouldThrowAsync <DbUpdateConcurrencyException>(); }
public async Task EditPost_WhenIdEqualsLeagueIdAndModelStateIsValidAndDbUpdateConcurrencyExceptionIsNotCaught_ShouldUpdateLeagueInDataStoreAndRedirectToIndexView() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); int id = 1; var league = new League { ID = 1 }; // Act var result = await testController.Edit(id, league); // Assert A.CallTo(() => leagueRepository.Update(league)).MustHaveHappenedOnceExactly(); A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly(); result.ShouldBeOfType <RedirectToActionResult>(); ((RedirectToActionResult)result).ActionName.ShouldBe <string>(nameof(testController.Index)); }
public async Task Details_LeagueDoesNotExist() { var lc = new LeaguesController(_context); var result = await lc.Details(4); Assert.IsType <NotFoundResult>(result); }
public async Task Details_LeagueCantBeNull() { var lc = new LeaguesController(_context); var result = await lc.Details(null); Assert.IsType <NotFoundResult>(result); }
public void CheckFunctionEdit() { // Add an initial League object to the database prior to editing League league = new League(); league.LeagueId = 1; league.Year = "2007"; databaseContext.League.Add(league); databaseContext.SaveChanges(); // Create the controller and call the Edit method, passing the new League object LeaguesController controller = new LeaguesController(databaseContext); league.Year = "2019"; var resultTask = controller.Edit(1, league); resultTask.Wait(); IActionResult result = resultTask.Result as IActionResult; // Fetch the league object from the database and check if it's value has been updated. var postLeagueTask = databaseContext.League.FirstOrDefaultAsync(l => l.LeagueId == 1); postLeagueTask.Wait(); var postLeague = postLeagueTask.Result; Assert.AreEqual(postLeague.Year, "2019"); }
public async Task PutLeague_WhenLeagueIsFoundAndSaved_ShouldReturnModelOfLeague() { // Arrange var leagueRepository = A.Fake <ILeagueRepository>(); League?league = new League(); A.CallTo(() => leagueRepository.GetLeagueAsync(A <int> .Ignored)).Returns(league); var sharedRepository = A.Fake <ISharedRepository>(); A.CallTo(() => sharedRepository.SaveChangesAsync()).Returns(1); var mapper = A.Fake <IMapper>(); var returnModel = new LeagueModel(); A.CallTo(() => mapper.Map <LeagueModel>(league)).Returns(returnModel); var linkGenerator = A.Fake <LinkGenerator>(); var testController = new LeaguesController(leagueRepository, sharedRepository, mapper, linkGenerator); int id = 1; var model = new LeagueModel(); // Act var result = await testController.PutLeague(id, model); // Assert A.CallTo(() => leagueRepository.GetLeagueAsync(id)).MustHaveHappenedOnceExactly(); A.CallTo(() => mapper.Map(model, league)).MustHaveHappenedOnceExactly(); A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly(); A.CallTo(() => mapper.Map <LeagueModel>(league)).MustHaveHappenedOnceExactly(); result.Value.ShouldBe(returnModel); }
public void ValidResponseCreate() { // Create the League controller LeaguesController controller = new LeaguesController(databaseContext); // Call the Create page IActionResult result = controller.Create() as IActionResult; // Check that the controller returned a valid response Assert.IsNotNull(result); }
public void TestGetTeamsByLeague() { IDatabaseFactory databaseFactory = new TestDatabaseFactory(); var leagueController = new LeaguesController(databaseFactory); var teams = leagueController.GetTeamsByLeague(1); Assert.That(teams.Count, Is.EqualTo(2), "The number of teams should be two"); Assert.IsTrue(teams.Contains("1")); Assert.IsTrue(teams.Contains("2")); }
public void TestGetAllLeagues() { IDatabaseFactory databaseFactory = new TestDatabaseFactory(); var leagueController = new LeaguesController(databaseFactory); List <League> leagues = null; leagues = (List <League>)leagueController.GetAllLeagues(); Assert.AreEqual(2, leagues.Count); }
public void TestGetLeagueByName() { IDatabaseFactory databaseFactory = new TestDatabaseFactory(); var leagueController = new LeaguesController(databaseFactory); var leagues = (List <League>)leagueController.Get("Soccer", "Coed"); Assert.That(leagues.Count, Is.EqualTo(2), "The number of leagues should be two"); Assert.AreEqual("Bucks County Coed", leagues[0].Name); Assert.AreEqual("Montgomery County Coed League over 30", leagues[1].Name); }
public void TestCreateLeague(League league, HttpStatusCode statusCode) { var databaseFactory = new TestDatabaseFactory(); var leagueController = new LeaguesController(databaseFactory); SetupControllerForTests(leagueController); HttpResponseMessage response; response = leagueController.PostLeague(league); Assert.That(response.StatusCode, Is.EqualTo(statusCode), "The expected status code is " + statusCode); }
public async Task Details_ReturnCorrectCountry() { var lc = new LeaguesController(_context); var result = await lc.Details(2); var viewResult = Assert.IsType <ViewResult>(result); var model = Assert.IsAssignableFrom <League>( viewResult.ViewData.Model); Assert.NotNull(viewResult); Assert.Equal("Inglaterra", model.Country); Assert.Equal("Premier League", model.Name); }
public async Task Index_ReturnsViewResult() { var lc = new LeaguesController(_context); var result = await lc.Index(); var viewResult = Assert.IsType <ViewResult>(result); var model = Assert.IsAssignableFrom <IEnumerable <League> >( viewResult.ViewData.Model); Assert.NotNull(model); // Porque já contém a Liga BWIN e a Premier League no contexto Assert.Equal(3, model.Count()); }
public void ValidResponseDelete() { // Create the League controller LeaguesController controller = new LeaguesController(databaseContext); // Call the Delete page and wait for a response var resultTask = controller.Delete(1); resultTask.Wait(); IActionResult result = resultTask.Result as IActionResult; // Check that the controller returned a valid response Assert.IsNotNull(result); }
public void CreateGet_ShouldReturnLeagueCreateView() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); // Act var result = testController.Create(); // Assert result.ShouldBeOfType <ViewResult>(); }
public void TestUpdateLeagueSuccess() { var league = new League { Type = "Soccer", Name = "West Chester coed over 30", Address = new Address { street = "400 Boot Rd", city = "Downingtown", state = "PA", zip = "19053" }, Image = "http://editor.swagger.io/photos" }; var databaseFactory = new TestDatabaseFactory(); var leagueController = new LeaguesController(databaseFactory); SetupControllerForTests(leagueController); // Add new league var response = leagueController.PostLeague(league); Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created), "The expected status code is 201 created"); // Get the newly created league var leagues = leagueController.Get(league.Type, league.Name); Assert.That(leagues.Count, Is.EqualTo(1), "The number of leagues shoud be one"); var createdLeague = leagues[0]; // Modify league name createdLeague.Name = createdLeague.Name + "_Updated"; // Update league var ret = leagueController.PutLeague(createdLeague.Id, createdLeague); // Get updated league leagues = leagueController.Get(league.Type, league.Name); Assert.That(leagues.Count, Is.EqualTo(1), "The number of leagues should be one"); var modifiedLeague = leagues[0]; Assert.That(modifiedLeague.Id, Is.EqualTo(createdLeague.Id), "The league Id should remain the same"); Assert.That(modifiedLeague.Name, Is.EqualTo(createdLeague.Name), "The league name should remain the same"); }
public async Task Details_WhenIdIsNull_ShouldReturnNotFound() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); int?id = null; // Act var result = await testController.Details(id); // Assert result.ShouldBeOfType <NotFoundResult>(); }
public void LeaguesController_Get_ReturnsAllLeagues() { //Arrange var repositoryMock = new Mock <IUnitOfWork>(); //Setup mock to dictate behavior of repository and it will return a list of leagues when called: repositoryMock.Setup(x => x.Repository.GetAll <League>()).Returns(leagues); //Create instance of leagues controller that will have mock repository injected; this is what will be used during the unit test var leaguesController = new LeaguesController(repositoryMock.Object); //Act var result = leaguesController.Get(); //Assert repositoryMock.Verify(x => x.Repository.GetAll <League>(), Times.Once); // Ensure repository was called Assert.IsNotNull(result); // Test to make sure return is not null Assert.IsInstanceOfType(result, typeof(IList <League>)); // Test type CollectionAssert.AreEqual(result.ToList(), leagues.ToList()); // Test the return is identical to what we expected }
public async Task CreatePost_WhenModelStateIsValid_ShouldAddLeagueToDataStoreAndRedirectToIndexView() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); var league = new League(); // Act var result = await testController.Create(league); // Assert A.CallTo(() => leagueRepository.AddAsync(league)).MustHaveHappenedOnceExactly(); A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly(); result.ShouldBeOfType <RedirectToActionResult>(); ((RedirectToActionResult)result).ActionName.ShouldBe <string>(nameof(testController.Index)); }
public async Task DeleteConfirmed_ShouldDeleteLeagueFromDataStoreAndRedirectToIndexView() { // Arrange var leaguesIndexViewModel = A.Fake <ILeaguesIndexViewModel>(); var leaguesDetailsViewModel = A.Fake <ILeaguesDetailsViewModel>(); var leagueRepository = A.Fake <ILeagueRepository>(); var sharedRepository = A.Fake <ISharedRepository>(); var testController = new LeaguesController(leaguesIndexViewModel, leaguesDetailsViewModel, leagueRepository, sharedRepository); int id = 1; // Act var result = await testController.DeleteConfirmed(id); // Assert A.CallTo(() => leagueRepository.DeleteAsync(id)).MustHaveHappenedOnceExactly(); A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly(); result.ShouldBeOfType <RedirectToActionResult>(); ((RedirectToActionResult)result).ActionName.ShouldBe <string>(nameof(testController.Index)); }
public void LeaguesController_GetWithValidLeagueId_ReturnsSingleLeague() { //Arrange const int leagueId = 1; var repositoryMock = new Mock <IUnitOfWork>(); var singleLeague = leagues.Where(x => x.Id == leagueId).AsQueryable(); //Setup mock to dictate behavior of repository and it will return a single league matching Id used in test when called: repositoryMock.Setup(x => x.Repository.GetQuery <League>(It.IsAny <Expression <Func <League, bool> > >())).Returns(singleLeague); //Create instance of leagues controller that will have mock repository injected; this is what will be used during the unit test var leaguesController = new LeaguesController(repositoryMock.Object); //Act var result = leaguesController.Get(leagueId); //Assert repositoryMock.Verify(x => x.Repository.GetQuery <League>(It.IsAny <Expression <Func <League, bool> > >()), Times.Once); // Ensure repository was called Assert.IsNotNull(result); // Test to make sure return is not null Assert.IsInstanceOfType(result, typeof(League)); // Test type Assert.AreEqual(result, singleLeague.SingleOrDefault()); // Test the return collection (with a single league) is identical to what we expected }