private async Task ConfirmEmail(string userId, string code, bool attemptConfirm = true, ResultType type = ResultType.Success)
{
var userManager = MockHelpers.CreateMockUserManager();
var signInManager = MockHelpers.CreateMockSignInManager();
var controller = new AccountController(userManager.Object, signInManager.Object, null);
var res = await controller.ConfirmEmail(userId, code);
var view = res as ViewResult;
if (attemptConfirm)
{
userManager.Verify(a => a.ConfirmEmailAsync(userId, code));
}
else
{
userManager.Verify(a => a.ConfirmEmailAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
Assert.NotNull(view);
switch (type)
{
case ResultType.BadRequest:
Assert.Equal("Error", view.ViewName);
break;
case ResultType.Success:
Assert.NotEqual("Error", view.ViewName);
break;
}
}
public async Task UploadImage_Success()
{
// create image
var img = MockHelpers.CreateImage(DateTime.Now.ToShortDateString(), "Caption 1", "location 1");
// create a new user
var pkUser = await MockHelpers.CreateNewUser(1, Guid.NewGuid().ToString(), "*****@*****.**", "Password@123", _fixture);
// get user manager
var _userManager = MockHelpers.CreateMockUserManager(pkUser);
var user = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, pkUser.Id)//,
//new Claim(ClaimTypes.Name, pkUser.UserName),
// new Claim(ClaimTypes.Email, pkUser.Email),
//new Claim(ClaimTypes.Role, "Admin")
}));
// upload image
var imgCont = new ImageController(_webHostEnvironment.Object, _configurationManager.Object, _userManager, _fixture.Context, _imapper);
imgCont.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var response = await imgCont.UploadImage(img) as StatusCodeResult;
Assert.Equal(201, response.StatusCode); //success
}
private async Task ChangePassword(string userId, string oldPassword, string newPassword, string confirmPassword, string username, bool useDependencyService = false, bool shouldReset = true, bool shouldReportSuccess = true)
{
var userManager = MockHelpers.CreateMockUserManager();
var signInManager = MockHelpers.CreateMockSignInManager();
var httpContext = MockHelpers.CreateMockHttpContext();
var logService = CreateMockLogService();
var container = new UnityContainer();
container.RegisterInstance(logService.Object);
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
var controller = new ManageController(userManager.Object, signInManager.Object, useDependencyService ? null : logService.Object);
var context = new ControllerContext {
HttpContext = httpContext.Object
};
controller.ControllerContext = context;
var model = new ChangePasswordViewModel
{
OldPassword = oldPassword,
NewPassword = newPassword,
ConfirmPassword = confirmPassword
};
MockHelpers.Validate(model, controller);
var result = await controller.ChangePassword(model);
if (shouldReportSuccess)
{
Assert.IsType <RedirectToRouteResult>(result);
var view = (RedirectToRouteResult)result;
Assert.Equal("Index", view.RouteValues["action"]);
}
else
{
Assert.IsType <ViewResult>(result);
}
if (shouldReset)
{
userManager.Verify(u => u.ChangePasswordAsync(userId, oldPassword, newPassword));
}
else
{
userManager.Verify(u => u.ChangePasswordAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
if (shouldReportSuccess && shouldReset)
{
logService.Verify(s => s.LogUserUpdated(username, username, It.Is <IEnumerable <string> >(i => i.Single() == "Password")));
}
else
{
logService.Verify(s => s.LogUserUpdated(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IEnumerable <string> >()), Times.Never);
}
}
private async Task ResetPassword(string userId, string token, string password, string passwordConfirm, string email, bool attemptReset = true, ResultType expectedResult = ResultType.Success)
{
var userManager = MockHelpers.CreateMockUserManager();
var signInManager = MockHelpers.CreateMockSignInManager();
var urlHelper = MockHelpers.CreateMockUrlHelper();
var logService = CreateMockLogService();
var container = new UnityContainer();
container.RegisterInstance(logService.Object);
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
var controller = new AccountController(userManager.Object, signInManager.Object, urlHelper.Object);
var model = new ResetPasswordViewModel
{
Code = token,
Password = password,
ConfirmPassword = passwordConfirm,
Email = email
};
MockHelpers.Validate(model, controller);
var result = await controller.ResetPassword(model);
if (attemptReset)
{
userManager.Verify(a => a.ResetPasswordAsync(userId, token, password));
}
switch (expectedResult)
{
case ResultType.ModelError:
var view = result as ViewResult;
Assert.NotNull(view);
break;
case ResultType.Success:
var redirect = result as RedirectToRouteResult;
Assert.NotNull(redirect);
Assert.Equal("ResetPasswordConfirmation", redirect.RouteValues["action"]);
Assert.Equal("Account", redirect.RouteValues["controller"]);
break;
}
if (attemptReset && expectedResult == ResultType.Success)
{
logService.Verify(s => s.LogUserUpdated(email, email, It.Is <IEnumerable <string> >(i => i.Single() == "Password")));
}
else
{
logService.Verify(s => s.LogUserUpdated(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IEnumerable <string> >()), Times.Never);
}
}
public async Task Get_ImageByID(string idType, int statusCode)
{
// create image
var img = MockHelpers.CreateImage(DateTime.Now.ToShortDateString(), "Caption 1", "location 1");
// create a new user
var pkUser = await MockHelpers.CreateNewUser(1, Guid.NewGuid().ToString(), "*****@*****.**", "Password@123", _fixture);
// get user manager
var _userManager = MockHelpers.CreateMockUserManager(pkUser);
var user = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, pkUser.Id)//,
//new Claim(ClaimTypes.Name, pkUser.UserName),
// new Claim(ClaimTypes.Email, pkUser.Email),
//new Claim(ClaimTypes.Role, "Admin")
}));
// upload image
var imgCont = new ImageController(_webHostEnvironment.Object, _configurationManager.Object, _userManager, _fixture.Context, _imapper);
imgCont.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
ActionResult upRes = await imgCont.UploadImage(img);
var imgContr = new ImageController(_webHostEnvironment.Object, _configurationManager.Object, _userManager, _fixture.Context, _imapper);
if (idType == "invalid")
{
var response = await imgContr.GetById(Guid.NewGuid().ToString()) as ObjectResult;
Assert.Equal(statusCode, response.StatusCode);
return;
}
// upload an image
var filtContr = new FilterController(_fixture.Context, _imapper);
var responseV = await filtContr.Images() as ObjectResult;
var imlst = responseV.Value as List <PikchaImageFilterDTO>;
var responseS = await imgContr.GetById(imlst[0].Id) as ObjectResult;
Assert.Equal(statusCode, responseS.StatusCode);
}
public void LogOff()
{
var userManager = MockHelpers.CreateMockUserManager();
var signInManager = MockHelpers.CreateMockSignInManager();
var urlHelper = MockHelpers.CreateMockUrlHelper();
var authManager = MockHelpers.CreateMockAuthenticationManager();
var controller = new AccountController(userManager.Object, signInManager.Object, urlHelper.Object, authManager.Object);
var result = controller.LogOff();
var redirect = result as RedirectToRouteResult;
authManager.Verify(a => a.SignOut(DefaultAuthenticationTypes.ApplicationCookie));
Assert.NotNull(redirect);
Assert.Equal("Index", redirect.RouteValues["action"]);
Assert.Equal("Home", redirect.RouteValues["controller"]);
}
private async Task ContinueForgotPassword(string email, string id = null, bool sendEmail = true, ResultType expectedResult = ResultType.Success)
{
var userManager = MockHelpers.CreateMockUserManager();
var signInManager = MockHelpers.CreateMockSignInManager();
var urlHelper = MockHelpers.CreateMockUrlHelper();
var controller = new AccountController(userManager.Object, signInManager.Object, urlHelper.Object);
var model = new ForgotPasswordViewModel
{
Email = email
};
MockHelpers.Validate(model, controller);
var result = await controller.ForgotPassword(model);
if (sendEmail)
{
userManager.Verify(a => a.GeneratePasswordResetEmailAsync(urlHelper.Object, id));
}
else
{
userManager.Verify(a => a.GeneratePasswordResetEmailAsync(urlHelper.Object, It.IsAny <string>()), Times.Never);
}
switch (expectedResult)
{
case ResultType.Success:
var redirect = result as RedirectToRouteResult;
Assert.NotNull(redirect);
Assert.Equal("Account", redirect.RouteValues["controller"]);
Assert.Equal("ForgotPasswordConfirmation", redirect.RouteValues["action"]);
break;
case ResultType.ModelError:
var view = result as ViewResult;
Assert.NotNull(view);
break;
}
}
private ImageController CreateAuthenticatedImageController(PikchaUser pkUser)
{
// get user manager
var _userManager = MockHelpers.CreateMockUserManager(pkUser);
var user = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, pkUser.Id)
}));
var imgfContr = new ImageController(_webHostEnvironment.Object, _configurationManager.Object, _userManager, _fixture.Context, _imapper);
imgfContr.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
return(imgfContr);
}
private async Task SubmitLogin(LoginViewModel loginModel, ApplicationUser user, string returnUrl, Result expectedResult)
{
var userManager = MockHelpers.CreateMockUserManager();
var signInManager = MockHelpers.CreateMockSignInManager();
var urlHelper = MockHelpers.CreateMockUrlHelper();
var logService = CreateMockLogService();
var controller = new AccountController(userManager.Object, signInManager.Object, urlHelper.Object, logService: logService.Object);
MockHelpers.Validate(loginModel, controller);
var result = await controller.Login(loginModel, returnUrl);
ViewResult vr;
switch (expectedResult)
{
case Result.VerificationFailure:
vr = result as ViewResult;
userManager.Verify(m => m.FindAsync(loginModel.Email, loginModel.Password), Times.AtLeastOnce);
signInManager.Verify(m => m.SignInAsync(It.IsAny <ApplicationUser>(), It.IsAny <bool>(), It.IsAny <bool>()), Times.Never);
logService.Verify(l => l.LogUserLoggedIn(It.IsAny <string>()), Times.Never);
Assert.NotNull(vr);
Assert.Equal(loginModel, vr.Model);
break;
case Result.ValidationFailure:
vr = result as ViewResult;
userManager.Verify(m => m.FindAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
signInManager.Verify(m => m.SignInAsync(It.IsAny <ApplicationUser>(), It.IsAny <bool>(), It.IsAny <bool>()), Times.Never);
logService.Verify(l => l.LogUserLoggedIn(It.IsAny <string>()), Times.Never);
Assert.NotNull(vr);
Assert.Equal(loginModel, vr.Model);
break;
case Result.RedirectToUri:
var rr = result as RedirectResult;
userManager.Verify(m => m.FindAsync(loginModel.Email, loginModel.Password), Times.AtLeastOnce);
signInManager.Verify(m => m.SignInAsync(user, loginModel.RememberMe, false), Times.Once);
urlHelper.Verify(m => m.IsLocalUrl(returnUrl), Times.AtLeastOnce);
logService.Verify(l => l.LogUserLoggedIn(loginModel.Email));
Assert.NotNull(rr);
Assert.Equal(returnUrl, rr.Url);
Assert.Equal(false, rr.Permanent);
break;
case Result.RedirectToHome:
var rtr = result as RedirectToRouteResult;
userManager.Verify(m => m.FindAsync(loginModel.Email, loginModel.Password), Times.AtLeastOnce);
signInManager.Verify(m => m.SignInAsync(user, loginModel.RememberMe, false), Times.Once);
urlHelper.Verify(m => m.IsLocalUrl(returnUrl), Times.AtLeastOnce);
logService.Verify(l => l.LogUserLoggedIn(loginModel.Email));
Assert.NotNull(rtr);
Assert.Equal("Index", rtr.RouteValues["action"]);
Assert.Equal("Home", rtr.RouteValues["controller"]);
Assert.Equal(false, rtr.Permanent);
break;
default:
Assert.True(false, "Bad expected result.");
break;
}
}
public async Task Get_ReturnsJson_ListofImages(string type, int start, int count, int expectedStatus)
{
// create image
var img = MockHelpers.CreateImage(DateTime.Now.ToShortDateString(), "Caption 1", "location 1");
// create a new user
var pkUser = await MockHelpers.CreateNewUser(1, Guid.NewGuid().ToString(), "*****@*****.**", "Password@123", _fixture);
// get user manager
var _userManager = MockHelpers.CreateMockUserManager(pkUser);
var user = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, pkUser.Id)//,
//new Claim(ClaimTypes.Name, pkUser.UserName),
// new Claim(ClaimTypes.Email, pkUser.Email),
//new Claim(ClaimTypes.Role, "Admin")
}));
// upload image
var imgCont = new ImageController(_webHostEnvironment.Object, _configurationManager.Object, _userManager, _fixture.Context, _imapper);
imgCont.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
ActionResult upRes = await imgCont.UploadImage(img);
// check uploaded images are there
var filtContr = new FilterController(_fixture.Context, _imapper);
ObjectResult response;
if (type == "artistId")
{
response = await filtContr.Images(type, start, count, pkUser.Id) as ObjectResult;
}
else
{
response = await filtContr.Images(type, start, count) as ObjectResult;
}
Assert.Equal(expectedStatus, response.StatusCode);
if (expectedStatus != StatusCodes.Status200OK)
{
return;
}
//var okResult = Assert.IsType<OkObjectResult>(response);
if (type == "pikcha100")
{
var imlst = response.Value as List <PikchaImageFilterDTO>;
// validate uploaded image
Assert.True(imlst.Exists(i => i.Title == img.Title));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + imlst[0].Thumbnail));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + imlst[0].Watermark));
return;
}
var lst = response.Value as List <PikchaImageFilterDTO>;
// validate uploaded image
Assert.True(lst.Exists(i => i.Title == img.Title));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + lst[0].Thumbnail));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + lst[0].Watermark));
}
