public void GetPartnerById_Successfully(int id)
{
IActionResult result = _mockController.GetPartnerById(id);
result.Should().BeOfType <OkObjectResult>();
result.As <OkObjectResult>().StatusCode.Should().Be(200);
result.As <OkObjectResult>().Value.ToString().Should().Contain("success = True");
}
public void CreatePartner_Successfully(JObject partner, JObject secondPartner)
{
IActionResult result = _mockController.CreateNewPartner(partner);
result.Should().BeOfType <OkObjectResult>();
result.As <OkObjectResult>().StatusCode.Should().Be(200);
result.As <OkObjectResult>().Value.ToString().Should().Contain("success = True");
}
public async Task AndFeedbackIsNotComplete_ThenResultIdRedirectToConfirmDetailsPage()
{
_result = await _controller.Index(_feedbackId);
_result.Should().BeOfType <RedirectToActionResult>();
_result.As <RedirectToActionResult>().ActionName.Should().Be("Index");
_result.As <RedirectToActionResult>().ControllerName.Should().Be("FeedbackConfirmDetails");
}
public async Task AndFeedbackIsComplete_ThenResultIsRedirectToCompletePage()
{
_mediator.Send(Arg.Any <GetVisitFeedbackRequest>()).Returns(new VisitFeedback()
{
Status = FeedbackStatus.Complete
});
_result = await _controller.Index(_feedbackId);
_result.Should().BeOfType <RedirectToActionResult>();
_result.As <RedirectToActionResult>().ActionName.Should().Be("Index");
_result.As <RedirectToActionResult>().ControllerName.Should().Be("FeedbackComplete");
}
public async Task DeleteUserPost_ShouldReturnRedirectToActionWhenValidUserId()
{
// Arrange
string tempDataSuccessMessage = null;
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.DeleteAsync(It.IsAny <User>()))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData.SetupSet(t => t["SuccessMessage"] = It.IsAny <string>())
.Callback((string key, object successMessage) => tempDataSuccessMessage = successMessage as string);
HomeController controller = new HomeController(null, userManager.Object, null);
controller.TempData = tempData.Object;
// Act
IActionResult actionResult = await controller.DestroyUser(FirstUserId);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>();
actionResult.As <RedirectToActionResult>().ActionName.Should().Be("AllUsers");
tempDataSuccessMessage.Should().Be(DeleteMessageSuccessfull);
}
public async Task DeleteUserPost_ShouldReturnViewWithModelWhenDeleteAsyncFailed()
{
// Arrange
IdentityDeleteUserViewModel formModel = new IdentityDeleteUserViewModel()
{
Username = "******"
};
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.DeleteAsync(It.IsAny <User>()))
.ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = "test"
}));
HomeController controller = new HomeController(null, userManager.Object, null);
// Act
IActionResult actionResult = await controller.DeleteUser(FirstUserId);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <IdentityDeleteUserViewModel>();
var returnedModel = model.As <IdentityDeleteUserViewModel>();
returnedModel.Username.Should().Be(formModel.Username);
}
public async Task EditUserPost_ShouldReturnRedirectToActionWhenValidUserId()
{
// Arrange
string tempDataSuccessMessage = null;
IdentityRegisterViewModel formModel = new IdentityRegisterViewModel()
{
Email = "NewEmail",
Username = "******"
};
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.UpdateAsync(It.IsAny <User>()))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData.SetupSet(t => t["SuccessMessage"] = It.IsAny <string>())
.Callback((string key, object successMessage) => tempDataSuccessMessage = successMessage as string);
HomeController controller = new HomeController(null, userManager.Object, null);
controller.TempData = tempData.Object;
// Act
IActionResult actionResult = await controller.EditUser(FirstUserId, formModel);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>();
actionResult.As <RedirectToActionResult>().ActionName.Should().Be("AllUsers");
tempDataSuccessMessage.Should().Be(EditUserMessageUpdated);
}
public async Task AddUserPost_ShouldReturnRedirectToActionWhenModelStateIsValid()
{
// Arrange
string tempDataSuccessMessage = null;
RegisterViewModel formModel = new RegisterViewModel()
{
Email = FirstUserEmail,
Username = FirstUserUsername,
};
Mock <UserManager <User> > userManager = UserManagerMock.GetNew();
userManager
.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData.SetupSet(t => t["SuccessMessage"] = It.IsAny <string>())
.Callback((string key, object successMessage) => tempDataSuccessMessage = successMessage as string);
HomeController controller = new HomeController(null, userManager.Object, null);
controller.TempData = tempData.Object;
// Act
IActionResult actionResult = await controller.AddUser(formModel);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>();
actionResult.As <RedirectToActionResult>().ActionName.Should().Be("AllUsers");
tempDataSuccessMessage.Should().Be(AddUserMessageSuccessfull);
}
public async Task AddUserPost_ShouldReturnViewWithModelWhenCreateAsyncFailed()
{
// Arrange
RegisterViewModel formModel = new RegisterViewModel()
{
Username = "******"
};
Mock <UserManager <User> > userManager = UserManagerMock.GetNew();
userManager
.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = "test"
}));
HomeController controller = new HomeController(null, userManager.Object, null);
// Act
IActionResult actionResult = await controller.AddUser(formModel);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <RegisterViewModel>();
var returnedModel = model.As <RegisterViewModel>();
returnedModel.Username.Should().Be(formModel.Username);
}
public async Task ManageRolesPost_ShouldReturnViewWithModelWhenRemoveFromRolesAsyncFailed()
{
// Arrange
IdentityRoleViewModel formModel = new IdentityRoleViewModel()
{
Username = FirstUserUsername
};
Mock <RoleManager <IdentityRole> > roleManager = this.GetAndSetRoleManagerMock();
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.RemoveFromRolesAsync(It.IsAny <User>(), It.IsAny <List <string> >()))
.ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = "test"
}));
HomeController controller = new HomeController(null, userManager.Object, roleManager.Object);
// Act
IActionResult actionResult = await controller.ManageRoles(FirstUserId, formModel);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <IdentityRoleViewModel>();
IdentityRoleViewModel returnedModel = model.As <IdentityRoleViewModel>();
returnedModel.Username.Should().Be(formModel.Username);
}
public async Task ChangeUserPasswordPost_ShouldReturnRedirectToActionWhenValidUserId()
{
// Arrange
string tempDataSuccessMessage = null;
ChangeUserPasswordFormModel formModel = new ChangeUserPasswordFormModel()
{
Username = FirstUserUsername
};
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.ResetPasswordAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData.SetupSet(t => t[WebConstants.TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object successMessage) => tempDataSuccessMessage = successMessage as string);
UsersController controller = new UsersController(null, null, userManager.Object);
controller.TempData = tempData.Object;
// Act
IActionResult actionResult = await controller.ChangeUserPassword(FirstUserId, formModel);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>();
actionResult.As <RedirectToActionResult>().ActionName.Should().Be("Index");
tempDataSuccessMessage.Should().Be(MessageUpdated);
}
private static void AssertModelStateErrorIsExpected(IActionResult result, string expectedErrorMessage)
{
var errorMessage = result.As <ViewResult>().ViewData.ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0).ToList().First().First().ErrorMessage;
errorMessage.Should().BeEquivalentTo(expectedErrorMessage);
}
public async Task Index_ShouldReturnFilteredUsersWithSearchTermNotNull()
{
// Arrange
Mock <IAdminService> adminService = new Mock <IAdminService>();
adminService
.Setup(service => service.GetAllUsers(1, SearchTerm))
.Returns(new List <UserBaseServiceModel>()
{
new UserBaseServiceModel()
{
Id = FirstUserId, Email = FirstUserEmail, Username = FirstUserUsername
},
});
UsersController controller = new UsersController(adminService.Object, null, null);
// Act
IActionResult actionResult = await controller.Index(1, SearchTerm);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <UsersPaginationModel>();
UsersPaginationModel returnedModel = model.As <UsersPaginationModel>();
returnedModel.Users.Should().Match(u => u.As <List <UserBaseServiceModel> >().Count() == 1);
returnedModel.Users.First().Should().Match(u => u.As <UserBaseServiceModel>().Id == FirstUserId);
returnedModel.Users.First().Should().Match(u => u.As <UserBaseServiceModel>().Username.ToLower().Contains(SearchTerm.ToLower()));
returnedModel.Search.Should().Be(SearchTerm);
}
private void AssertRedirectToCompanyRoutes(IActionResult result)
{
result.Should().BeOfType <RedirectToActionResult>();
var redirectResult = result.As <RedirectToActionResult>();
redirectResult.ActionName.Should().Be(WebConstants.Action.CompanyAllRoutes);
}
public void Index_ReturnOneToDoList()
{
//Arrange
IToDoListService toDoListServiceFake = A.Fake <IToDoListService>();
List <ToDoList> toDoLists = new List <ToDoList>
{
CreateToDoListDefault()
};
A.CallTo(() => toDoListServiceFake.ToDoLists())
.Returns(toDoLists);
ToDoListController sut = CreateSut(toDoListServiceFake);
//Act
IActionResult result = sut.Index().Result;
//Assert
result
.As <ViewResult>()
.Model
.As <List <ToDoList> >()
.Should()
.HaveCount(1);
}
public async Task Index_ShouldReturnPartialViewWhenAjaxRequestAndValidMovieId()
{
// Arrange
Mock <IMovieDbService> movieDbService = new Mock <IMovieDbService>();
movieDbService
.Setup(ms => ms.GetMovieDetailsAsync(It.IsAny <int>()))
.ReturnsAsync(new MovieDetailsServiceModel()
{
Id = FirstMovieId, Title = FirstMovieTitle, ProductionYear = FirstMovieProductionYear
});
HomeController controller = new HomeController(
movieDbService.Object, null, null, null, null, null, null, null);
controller.InjectAjaxRequest(true);
// Act
IActionResult actionResult = await controller.Index(FirstMovieId);
// Assert
actionResult.Should().BeOfType <PartialViewResult>();
object model = actionResult.As <PartialViewResult>().Model;
model.Should().BeOfType <MovieIndexViewModel>();
MovieIndexViewModel returnedModel = model.As <MovieIndexViewModel>();
returnedModel.MovieDetails.Id.Should().Be(FirstMovieId);
}
public void EditPost_InvalidModalState_ReturnViewWithOneModelStateError()
{
//Arrange
int toDoListId = 1;
ToDoList toDoList = new ToDoList
{
Id = 1
};
IToDoListService toDoListServiceFake = A.Fake <IToDoListService>();
ToDoListController sut = CreateSut(toDoListServiceFake);
string modelStateErrorKey = "Name";
sut.ModelState.AddModelError(modelStateErrorKey, "Name is required.");
//Act
IActionResult result = sut.Edit(toDoListId, toDoList).Result;
//Assert
result
.As <ViewResult>()
.ViewData
.ModelState[modelStateErrorKey]
.Errors
.Should()
.HaveCount(1);
}
public async Task ChangeUserPasswordPost_ShouldReturnViewWithModelWhenResetPasswordAsyncFailed()
{
// Arrange
ChangeUserPasswordFormModel formModel = new ChangeUserPasswordFormModel()
{
Username = FirstUserUsername
};
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.ResetPasswordAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = "test"
}));
UsersController controller = new UsersController(null, null, userManager.Object);
// Act
IActionResult actionResult = await controller.ChangeUserPassword(FirstUserId, formModel);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <ChangeUserPasswordFormModel>();
ChangeUserPasswordFormModel returnedModel = model.As <ChangeUserPasswordFormModel>();
returnedModel.Username.Should().Be(formModel.Username);
}
protected void AssertRedirectToHome(IActionResult result)
{
result.Should().BeOfType <RedirectToActionResult>();
var model = result.As <RedirectToActionResult>();
model.ActionName.Should().Be(WebConstants.Action.Index);
model.ControllerName.Should().Be(WebConstants.Controller.Home);
}
private void AssertRedirectToCompanyDetails(IActionResult result)
{
result.Should().BeOfType <RedirectToActionResult>();
var model = result.As <RedirectToActionResult>();
model.ActionName.Should().Be(WebConstants.Action.Details);
model.ControllerName.Should().Be(WebConstants.Controller.Companies);
}
private void ShouldReturnCorrectContent()
{
var robotsFactoryMock = new Mock <IRobotsTxtFactory>(MockBehavior.Strict);
robotsFactoryMock.Setup(rf => rf.Create()).Returns("User-agent: *");
var seoController = new SeoController(robotsFactoryMock.Object, GetSitemapFactory());
IActionResult robotsResult = seoController.GetRobots();
robotsResult.As <ContentResult>().Content.Should().BeEquivalentTo("User-agent: *");
}
private void ShouldReturnSitemap()
{
var sitemap = new Sitemap();
var sitemapFactoryMock = new Mock <ISitemapFactory>(MockBehavior.Strict);
sitemapFactoryMock.Setup(sf => sf.Create()).Returns(sitemap);
var seoController = new SeoController(GetRobotsTxtFactory(), sitemapFactoryMock.Object);
IActionResult sitemapResult = seoController.GetSitemap();
sitemapResult.As <ObjectResult>().Value.Should().BeSameAs(sitemap);
}
private void ShouldReturnCorrectContentType()
{
var robotsFactoryMock = new Mock <IRobotsTxtFactory>(MockBehavior.Strict);
robotsFactoryMock.Setup(rf => rf.Create()).Returns(string.Empty);
var seoController = new SeoController(robotsFactoryMock.Object, GetSitemapFactory());
IActionResult robotsResult = seoController.GetRobots();
robotsResult.As <ContentResult>().ContentType.Should().BeEquivalentTo("text/plain; charset=utf-8");
}
private void AssertEditCompanyForm(IActionResult result)
{
var model = result.As <ViewResult>().Model;
model.Should().BeOfType <EditCompanyProfileFormModel>();
var form = model.As <EditCompanyProfileFormModel>();
form.Email.Should().Be(CompanyEmail);
form.CurrentLogo.Should().BeEquivalentTo(CompanyLogo);
form.PhoneNumber.Should().Be(CompanyPhone);
form.Username.Should().Be(UserUsername);
}
public async Task Index_ShouldReturnCorrectViewModelWhenNotAjaxRequest()
{
// Arrange
var allMovies = new List <MovieBaseServiceModel>()
{
new MovieBaseServiceModel()
{
Id = FirstMovieId, ProductionYear = FirstMovieProductionYear, Title = FirstMovieTitle
},
new MovieBaseServiceModel()
{
Id = SecondMovieId, ProductionYear = SecondMovieProductionYear, Title = SecondMovieTitle
},
new MovieBaseServiceModel()
{
Id = ThirdMovieId, ProductionYear = ThirdMovieProductionYear, Title = ThirdMovieTitle
}
};
Mock <IMovieDbService> movieDbService = new Mock <IMovieDbService>();
movieDbService
.Setup(ms => ms.GetAllMoviesAsync())
.ReturnsAsync(allMovies);
movieDbService
.Setup(ms => ms.GetMovieDetailsAsync(It.IsAny <int>()))
.ReturnsAsync(new MovieDetailsServiceModel()
{
Id = FirstMovieId, Title = FirstMovieTitle, ProductionYear = FirstMovieProductionYear
});
HomeController controller = new HomeController(
movieDbService.Object, null, null, null, null, null, null, null);
controller.InjectAjaxRequest(false);
// Act
IActionResult actionResult = await controller.Index(FirstMovieId);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <MovieIndexViewModel>();
MovieIndexViewModel returnedModel = model.As <MovieIndexViewModel>();
returnedModel.AllMovies.Should().Match(m => m.As <List <MovieBaseServiceModel> >().Count() == 3);
returnedModel.MovieDetails.Should().Match(m => m.As <MovieDetailsServiceModel>().Id == FirstMovieId);
}
private void AssertAddToRoleInvalidRequest(string msg, AddUserToRoleFormModel model, IActionResult result, string assertMsg)
{
msg.Should().Be(assertMsg);
result.Should().BeOfType <RedirectToActionResult>();
var redirect = result.As <RedirectToActionResult>();
redirect.ActionName.Should().Be("UserDetails");
redirect.ControllerName.Should().Be("Users");
redirect.RouteValues.Keys.Should().Contain("area");
redirect.RouteValues["area"].Should().Be(Administration);
redirect.RouteValues.Keys.Should().Contain("id");
redirect.RouteValues["id"].Should().Be(model.UserId);
}
private void AssertIndex(IActionResult result)
{
result.Should().BeOfType <ViewResult>();
var model = result.As <ViewResult>().Model;
model.Should().BeOfType <List <ChartServiceModel> >();
var formModel = model.As <List <ChartServiceModel> >();
formModel.First().Points.Should().Be(firstPoints);
formModel.Last().Points.Should().Be(secondPoints);
}
public async Task ChangeUserRolesPost_ShouldReturnRedirectToActionWhenValidUserId()
{
// Arrange
string tempDataSuccessMessage = null;
ChangeUserRolesFormModel formModel = new ChangeUserRolesFormModel()
{
AvailableRoles = new List <string>(),
SelectedRoles = new List <string>()
{
GlobalConstants.ModeratorRole
},
Username = FirstUserUsername
};
Mock <RoleManager <IdentityRole> > roleManager = this.GetAndSetRoleManagerMock();
roleManager
.Setup(rm => rm.RoleExistsAsync(It.IsAny <string>()))
.ReturnsAsync(true);
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.RemoveFromRolesAsync(It.IsAny <User>(), It.IsAny <List <string> >()))
.ReturnsAsync(IdentityResult.Success);
userManager
.Setup(um => um.AddToRolesAsync(It.IsAny <User>(), It.IsAny <List <string> >()))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData.SetupSet(t => t[WebConstants.TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object successMessage) => tempDataSuccessMessage = successMessage as string);
UsersController controller = new UsersController(null, roleManager.Object, userManager.Object);
controller.TempData = tempData.Object;
// Act
IActionResult actionResult = await controller.ChangeUserRoles(FirstUserId, formModel);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>();
actionResult.As <RedirectToActionResult>().ActionName.Should().Be("Index");
tempDataSuccessMessage.Should().Be(MessageUpdated);
}
public async Task GetProfileVariationPointers_Returns_Funding_Streams_Given_A_Successful_Request()
{
string aValidSpecificationId = "ABC";
List <ProfileVariationPointer> aValidProfileVariationPointers = CreateTestProfileVariationPointers().ToList();
_specificationsApiClient
.GetProfileVariationPointers(aValidSpecificationId)
.Returns(Task.FromResult(
new ApiResponse <IEnumerable <ProfileVariationPointer> >(HttpStatusCode.OK, aValidProfileVariationPointers)));
IActionResult result = await _specificationController.GetProfileVariationPointers(aValidSpecificationId);
result.As <OkObjectResult>().Value.As <List <ProfileVariationPointer> >().Should()
.BeEquivalentTo(aValidProfileVariationPointers);
}
public async Task GetDistinctFundingStreamsForSpecifications_Returns_Funding_Streams_Given_A_Successful_Request()
{
List <string> expectedFundingStreams = new List <string>
{
"PSG",
"DSG"
};
_specificationsApiClient
.GetDistinctFundingStreamsForSpecifications()
.Returns(Task.FromResult(new ApiResponse <IEnumerable <string> >(HttpStatusCode.OK, expectedFundingStreams)));
IActionResult result = await _specificationController.GetDistinctFundingStreamsForSpecifications();
result.As <OkObjectResult>().Value.As <List <string> >().Count.Should().Be(expectedFundingStreams.Count);
}
