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
}
