public void NavigatedTo_CalculatesTotalNumberOfItemsInCart()
{
var shoppingCart = new ShoppingCart(new List <ShoppingCartItem>()
{
new ShoppingCartItem {
Quantity = 1
},
new ShoppingCartItem {
Quantity = 2
}
});
var shoppingCartRepository = new MockShoppingCartRepository();
var eventAggregator = new MockEventAggregator();
eventAggregator.GetEventDelegate = type =>
{
if (type == typeof(ShoppingCartUpdatedEvent))
{
return(new ShoppingCartUpdatedEvent());
}
if (type == typeof(ShoppingCartItemUpdatedEvent))
{
return(new ShoppingCartItemUpdatedEvent());
}
return(null);
};
var accountService = new MockAccountService();
accountService.VerifyUserAuthenticationAsyncDelegate = () => Task.FromResult((UserInfo)null);
shoppingCartRepository.GetShoppingCartAsyncDelegate = () => Task.FromResult(shoppingCart);
var target = new ShoppingCartTabUserControlViewModel(shoppingCartRepository, eventAggregator, null, null, accountService);
Assert.AreEqual(3, target.ItemCount);
}
public void CartUpdatedEventRaised_WhenUserChanged()
{
var shoppingCartUpdatedRaised = false;
var accountService = new MockAccountService();
var shoppingCartUpdatedEvent = new MockShoppingCartUpdatedEvent()
{
PublishDelegate = () => shoppingCartUpdatedRaised = true
};
var eventAggregator = new MockEventAggregator()
{
GetEventDelegate = (a) => shoppingCartUpdatedEvent
};
var shoppingCartService = new MockShoppingCartService()
{
MergeShoppingCartsAsyncDelegate = (s, s1) => Task.FromResult(false)
};
var target = new ShoppingCartRepository(shoppingCartService, accountService, eventAggregator, new MockSessionStateService());
accountService.RaiseUserChanged(new UserInfo {
UserName = "******"
}, null);
Assert.IsTrue(shoppingCartUpdatedRaised);
}
public async Task Login_InvalidState_BadRequest()
{
// Arrange
const string field = "apple-error";
const string errorMessage = "how do you like them apples";
var service = new MockAccountService
{
MLogin = (model) => "Doesn't really matter a second time"
};
var controller = new AccountController(service);
controller.ModelState.AddModelError(field, errorMessage);
// Act
var result = await controller.Login(MockLoginViewModel.Get(0)) as BadRequestObjectResult;
var error = result?.Value as SerializableError;
// Assert
Assert.NotNull(error);
Assert.Equal(400, result.StatusCode);
Assert.Single(error.Keys);
Assert.True(error.ContainsKey(field));
Assert.Equal(new[] { errorMessage }, error.GetValueOrDefault(field));
}
public async Task AccountController_ChangePassword_Unsuccessful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockChangeUserPasswordAsync(false);
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var changePasswordViewModel = new ViewModel.ChangePassword
{
CurrentPassword = "******",
Password = "******",
ConfirmPassword = "******"
};
var result = await accountController.ChangePassword(changePasswordViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.ChangePassword>(viewResult.ViewData.Model);
string messages = string.Join("; ", accountController.ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage));
Assert.IsType <ViewModel.ChangePassword>(model);
Assert.Equal(1, accountController.ModelState.ErrorCount);
Assert.Equal("Incorrect password", messages);
Assert.Equal("", model.SuccessMessage);
}
public async Task AccountController_DeleteAccount_Unsuccessful_IncorrectPassword()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockDeleteUserAccountAsync("Incorrect password");
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var deleteAccountViewModel = new ViewModel.DeleteAccount
{
Password = "******"
};
var result = await accountController.DeleteAccount(deleteAccountViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.DeleteAccount>(viewResult.ViewData.Model);
string messages = string.Join("; ", accountController.ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage));
Assert.IsType <ViewModel.DeleteAccount>(model);
Assert.Equal(1, accountController.ModelState.ErrorCount);
Assert.Equal("Incorrect password", messages);
Assert.Equal("", model.SuccessMessage);
}
public async Task FiringSignInCommand_Persists_Credentials_And_Turns_Invisible()
{
bool accountServiceSignInCalled = false;
bool flyoutClosed = false;
var accountService = new MockAccountService()
{
SignInUserAsyncDelegate = (username, password, useCredentialStore) =>
{
Assert.AreEqual("TestUsername", username);
Assert.AreEqual("TestPassword", password);
Assert.IsTrue(useCredentialStore);
accountServiceSignInCalled = true;
return(Task.FromResult(true));
}
};
var target = new SignInFlyoutViewModel(accountService, null, null)
{
CloseFlyout = () => flyoutClosed = true,
UserName = "******",
Password = "******",
SaveCredentials = true
};
await target.SignInCommand.Execute();
Assert.IsTrue(accountServiceSignInCalled);
Assert.IsTrue(flyoutClosed);
}
public void Checkout_WhenAnonymous_ShowsSignInFlyout()
{
var modalCalled = false;
var accountService = new MockAccountService
{
VerifyUserAuthenticationAsyncDelegate = () => Task.FromResult <UserInfo>(null)
};
var signInUserControlViewModel = new MockSignInUserControlViewModel
{
OpenDelegate = (s) =>
{
modalCalled = true;
Assert.IsNotNull(s);
}
};
var checkoutDataRepository = new MockCheckoutDataRepository()
{
GetDefaultShippingAddressAsyncDelegate = () => null,
GetDefaultBillingAddressAsyncDelegate = () => null,
GetDefaultPaymentMethodAsyncDelegate = () => Task.FromResult <PaymentMethod>(null)
};
var eventAggregator = new MockEventAggregator
{
GetEventDelegate = type => new MockShoppingCartUpdatedEvent()
};
var target = new ShoppingCartPageViewModel(null, new MockNavigationService(), accountService, signInUserControlViewModel, null, null, checkoutDataRepository, null, eventAggregator);
target.CheckoutCommand.Execute();
Assert.IsTrue(modalCalled);
}
public void ShoppingCartUpdated_WhenShoppingCartChanged()
{
var navigationService = new MockNavigationService();
var accountService = new MockAccountService();
var shoppingCartRepository = new MockShoppingCartRepository();
shoppingCartRepository.GetShoppingCartAsyncDelegate = () =>
{
ShoppingCart shoppingCart = new ShoppingCart(new ObservableCollection <ShoppingCartItem>())
{
Currency = "USD"
};
return(Task.FromResult(shoppingCart));
};
bool signInUserControlOnNavigatedToCalled = false;
var signInUserControlViewModel = new MockSignInUserControlViewModel()
{
OnNavigatedToDelegate = (a, b, c) => signInUserControlOnNavigatedToCalled = true
};
var eventAggregator = new MockEventAggregator();
var shoppingCartUpdatedEvent = new ShoppingCartUpdatedEvent();
eventAggregator.GetEventDelegate = type => shoppingCartUpdatedEvent;
var target = new ShoppingCartPageViewModel(shoppingCartRepository, navigationService, accountService, signInUserControlViewModel, null, null, null, null, eventAggregator);
target.OnNavigatedTo(new NavigatedToEventArgs {
Parameter = null, NavigationMode = NavigationMode.New
}, null);
Assert.AreEqual("$0.00", target.FullPrice);
shoppingCartRepository.GetShoppingCartAsyncDelegate = () =>
{
var shoppingCartItems = new ObservableCollection <ShoppingCartItem>
{
new ShoppingCartItem()
{
Product = new Product {
ListPrice = 100, ProductNumber = "p1", ImageUri = new Uri("http://image")
}, Currency = "USD", Quantity = 2
},
};
ShoppingCart shoppingCart = new ShoppingCart(new ObservableCollection <ShoppingCartItem>(shoppingCartItems))
{
Currency = "USD"
};
return(Task.FromResult(shoppingCart));
};
shoppingCartUpdatedEvent.Publish(null);
Assert.IsTrue(signInUserControlOnNavigatedToCalled);
Assert.AreEqual("$200.00", target.FullPrice);
}
public AccountControllerTest()
{
_mockService = new MockAccountService();
_mockUserManager = new MockUserManager();
_mockUserValidator = new MockUserValidator();
_accountsController = GetAccountsControllerAdmin(_mockService, _mockUserManager, _mockUserValidator);
_accountsControllerNoRole = GetAccountsControllerNoRole(_mockService, _mockUserManager, _mockUserValidator);
_testAppUser = new AppUser {
Email = "*****@*****.**", Id = _idTestAppUser, UserName = "******"
};
}
private AccountsController GetAccountsControllerNoRole(MockAccountService mockService, MockUserManager mockUserManager, MockUserValidator mockUserValidator)
{
var authService = MockAuthorizationService.BuildAuthorizationService(services =>
{
services.AddScoped <IAccountService>(sp => mockService.Object);
services.AddScoped <IAuthorizationHandler, AdminAuthorizationHandler>();
});
var controller = new AccountsController(authService, mockUserManager.Object, mockUserValidator.Object, mockService.Object);
return(controller);
}
public async Task CachedAddressesAndPaymentMethodsExpire_WhenUserChanged()
{
var accountService = new MockAccountService();
var target = new CheckoutDataRepository(SetupAddressService(), SetupPaymentMethodService(), accountService);
var paymentMethods = await target.GetAllPaymentMethodsAsync();
Assert.AreSame(await target.GetAllPaymentMethodsAsync(), paymentMethods, "Cached data should be same.");
accountService.RaiseUserChanged(null, null);
Assert.AreNotSame(await target.GetAllPaymentMethodsAsync(), paymentMethods);
}
public void UserName_ReturnsLastSignedInUser_IfAvailable()
{
var accountService = new MockAccountService()
{
SignedInUser = new UserInfo {
UserName = "******"
}
};
var target = new SignInFlyoutViewModel(accountService, null, null);
Assert.AreEqual("TestUserName", target.UserName);
Assert.IsFalse(target.IsNewSignIn);
}
public async Task Login_NullModel_BadRequest()
{
// Arrange
var service = new MockAccountService {
MLogin = (model) => "Doesn't really matter"
};
var controller = new AccountController(service);
// Act
var result = await controller.Login(null) as BadRequestResult;
// Assert
Assert.NotNull(result);
Assert.Equal(400, result.StatusCode);
}
public void ProcessFormAsync_WithServerValidationError_ShowsMessage()
{
var shippingAddressPageViewModel = new MockShippingAddressPageViewModel()
{
ValidateFormDelegate = () => true,
ProcessFormAsyncDelegate = () => Task.Delay(0),
Address = new Address()
};
var billingAddressPageViewModel = new MockBillingAddressPageViewModel()
{
ValidateFormDelegate = () => true,
ProcessFormAsyncDelegate = () => Task.Delay(0),
Address = new Address()
};
var paymentMethodPageViewModel = new MockPaymentMethodPageViewModel()
{
ValidateFormDelegate = () => true,
ProcessFormAsyncDelegate = async() => await Task.Delay(0),
PaymentMethod = new PaymentMethod()
};
var accountService = new MockAccountService()
{
VerifyUserAuthenticationAsyncDelegate = () => Task.FromResult(new UserInfo()),
SignedInUser = new UserInfo()
};
var shoppingCartRepository = new MockShoppingCartRepository()
{
GetShoppingCartAsyncDelegate =
() => Task.FromResult(new ShoppingCart(null))
};
var orderRepository = new MockOrderRepository()
{
CreateBasicOrderAsyncDelegate = (s, cart, arg3, arg4, arg5) =>
{
var result = new ModelValidationResult();
result.ModelState.Add("order.ShippingAddress.ZipCode", new List <string> {
"Validation Message"
});
throw new ModelValidationException(result);
}
};
var target = new CheckoutHubPageViewModel(new MockNavigationService(), accountService, orderRepository, shoppingCartRepository, shippingAddressPageViewModel,
billingAddressPageViewModel, paymentMethodPageViewModel, null, null);
target.GoNextCommand.Execute();
Assert.IsTrue(target.IsShippingAddressInvalid);
}
public async Task Submit_WhenAnonymous_ShowsSignInControl()
{
bool showSignInCalled = false;
var accountService = new MockAccountService()
{
VerifySavedCredentialsAsyncDelegate = () => Task.FromResult <UserInfo>(null)
};
var signInUserControlViewModel = new MockSignInUserControlViewModel()
{
OpenDelegate = (a) => showSignInCalled = true
};
var target = new CheckoutSummaryPageViewModel(new MockNavigationService(), null, null, null, null, null, accountService, null, null, signInUserControlViewModel);
await target.SubmitCommand.Execute();
Assert.IsTrue(showSignInCalled);
}
public async Task AccountController_DeleteAccount_Successful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockDeleteUserAccountAsync("");
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var deleteAccountViewModel = new ViewModel.DeleteAccount
{
Password = "******"
};
var result = (RedirectToActionResult)await accountController.DeleteAccount(deleteAccountViewModel);
Assert.Equal("Home", result.ControllerName);
Assert.Equal("Index", result.ActionName);
}
public async Task SubmitValidOrder_NavigatesToOrderConfirmation()
{
bool navigateCalled = false;
bool clearHistoryCalled = false;
bool clearCartCalled = false;
var navigationService = new MockNavigationService();
navigationService.NavigateDelegate = (s, o) =>
{
Assert.AreEqual("OrderConfirmation", s);
navigateCalled = true;
return(true);
};
navigationService.ClearHistoryDelegate = () =>
{
clearHistoryCalled = true;
};
var accountService = new MockAccountService()
{
VerifySavedCredentialsAsyncDelegate = () => Task.FromResult <UserInfo>(new UserInfo())
};
var orderService = new MockOrderService()
{
// the order is valid, it can be processed
ProcessOrderAsyncDelegate = (o) => Task.FromResult(true)
};
var resourcesService = new MockResourceLoader()
{
GetStringDelegate = (key) => key
};
var shoppingCartRepository = new MockShoppingCartRepository();
shoppingCartRepository.ClearCartAsyncDelegate = () =>
{
clearCartCalled = true;
return(Task.Delay(0));
};
var target = new CheckoutSummaryPageViewModel(navigationService, orderService, null, null, null, shoppingCartRepository, accountService, resourcesService, null, null);
await target.SubmitCommand.Execute();
Assert.IsTrue(navigateCalled);
Assert.IsTrue(clearHistoryCalled);
Assert.IsTrue(clearCartCalled);
}
public void SubmitInvalidOrder_CallsErrorDialog()
{
bool successDialogCalled = false;
bool errorDialogCalled = false;
var navigationService = new MockNavigationService();
var accountService = new MockAccountService()
{
VerifySavedCredentialsAsyncDelegate = () => Task.FromResult <UserInfo>(new UserInfo())
};
var orderService = new MockOrderService()
{
// the order is invalid, it cannot be processed
ProcessOrderAsyncDelegate = (o) =>
{
var modelValidationResult = new ModelValidationResult();
modelValidationResult.ModelState.Add("someKey", new List <string>()
{
"the value of someKey is invalid"
});
throw new ModelValidationException(modelValidationResult);
}
};
var resourcesService = new MockResourceLoader()
{
GetStringDelegate = (key) => key
};
var alertService = new MockAlertMessageService()
{
ShowAsyncDelegate = (dialogTitle, dialogMessage) =>
{
successDialogCalled = dialogTitle.ToLower().Contains("purchased");
errorDialogCalled = !successDialogCalled;
return(Task.FromResult(successDialogCalled));
}
};
var target = new CheckoutSummaryPageViewModel(navigationService, orderService, null, null, null, null, accountService, resourcesService, alertService, null);
target.SubmitCommand.Execute();
Assert.IsFalse(successDialogCalled);
Assert.IsTrue(errorDialogCalled);
}
public async Task FiringSignInCommand_WithNotRememberPassword_DoesNotSaveInCredentialStore()
{
var accountService = new MockAccountService()
{
SignInUserAsyncDelegate = (username, password, useCredentialStore) =>
{
Assert.IsFalse(useCredentialStore);
return(Task.FromResult(true));
}
};
var target = new SignInFlyoutViewModel(accountService, null, null)
{
CloseFlyout = () => Assert.IsTrue(true),
SaveCredentials = false
};
await target.SignInCommand.Execute();
}
public async Task AccountController_Login_Successful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockLoginUserAsync(true);
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var loginViewModel = new ViewModel.Login
{
Email = "*****@*****.**",
Password = "******",
ReturnUrl = null
};
var result = (RedirectToActionResult)await accountController.Login(loginViewModel);
Assert.Equal("Home", result.ControllerName);
Assert.Equal("Index", result.ActionName);
}
public async Task Login_Valid_OkWithToken()
{
// Arrange
const string mockToken = "This is not a love-token song";
var service = new MockAccountService {
MLogin = (model) => string.Copy(mockToken)
};
var controller = new AccountController(service);
// Act
var result = await controller.Login(MockLoginViewModel.Get(1)) as OkObjectResult;
var tokenReceived = result?.Value as string;
// Assert
Assert.NotNull(result);
Assert.Equal(200, result.StatusCode);
Assert.NotNull(tokenReceived);
Assert.Equal(string.Copy(mockToken), tokenReceived);
}
public async Task AccountController_Register_Successful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockRegisterUserAsync(true);
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var registerViewModel = new ViewModel.Register
{
Name = "Test User",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var result = (RedirectToActionResult)await accountController.Register(registerViewModel);
Assert.Equal("Home", result.ControllerName);
Assert.Equal("Index", result.ActionName);
}
public async Task ExecuteGoNextCommand_DoNothing_IfViewModelsAreInvalid()
{
bool formProcessStarted = false;
var accountService = new MockAccountService()
{
VerifyUserAuthenticationAsyncDelegate = () =>
{
// The process starts with a call to retrieve the logged user
formProcessStarted = true;
return(Task.FromResult(new UserInfo()));
}
};
var shippingAddressPageViewModel = new MockShippingAddressPageViewModel();
var billingAddressPageViewModel = new MockBillingAddressPageViewModel();
var paymentMethodPageViewModel = new MockPaymentMethodPageViewModel();
var target = new CheckoutHubPageViewModel(new MockNavigationService(), accountService, null, null,
shippingAddressPageViewModel, billingAddressPageViewModel, paymentMethodPageViewModel, null, null);
// ShippingAddress invalid only
shippingAddressPageViewModel.ValidateFormDelegate = () => false;
billingAddressPageViewModel.ValidateFormDelegate = () => true;
paymentMethodPageViewModel.ValidateFormDelegate = () => true;
await target.GoNextCommand.Execute();
Assert.IsFalse(formProcessStarted);
// BillingAddress invalid only
shippingAddressPageViewModel.ValidateFormDelegate = () => true;
billingAddressPageViewModel.ValidateFormDelegate = () => false;
paymentMethodPageViewModel.ValidateFormDelegate = () => true;
Assert.IsFalse(formProcessStarted);
// PaymentMethod invalid only
shippingAddressPageViewModel.ValidateFormDelegate = () => true;
billingAddressPageViewModel.ValidateFormDelegate = () => true;
paymentMethodPageViewModel.ValidateFormDelegate = () => false;
Assert.IsFalse(formProcessStarted);
}
public async Task AccountController_DeleteAccount_Unsuccessful_Error()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockDeleteUserAccountAsync("Error deleting account");
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var deleteAccountViewModel = new ViewModel.DeleteAccount
{
Password = "******"
};
var result = await accountController.DeleteAccount(deleteAccountViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.DeleteAccount>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.DeleteAccount>(model);
Assert.Equal("Error deleting account", model.ErrorMessage);
Assert.Equal("", model.SuccessMessage);
}
public void ShoppingCartUpdated_WithNullCart_SetsItemCountZero()
{
var shoppingCartRepository = new MockShoppingCartRepository();
var shoppingCart = new ShoppingCart(new List <ShoppingCartItem> {
new ShoppingCartItem {
Quantity = 99
}
});
shoppingCartRepository.GetShoppingCartAsyncDelegate = () => Task.FromResult(shoppingCart);
var eventAggregator = new MockEventAggregator();
var shoppingCartUpdatedEvent = new ShoppingCartUpdatedEvent();
eventAggregator.GetEventDelegate = type =>
{
if (type == typeof(ShoppingCartUpdatedEvent))
{
return(shoppingCartUpdatedEvent);
}
if (type == typeof(ShoppingCartItemUpdatedEvent))
{
return(new ShoppingCartItemUpdatedEvent());
}
return(null);
};
var accountService = new MockAccountService();
accountService.VerifyUserAuthenticationAsyncDelegate = () => Task.FromResult((UserInfo)null);
var target = new ShoppingCartTabUserControlViewModel(shoppingCartRepository, eventAggregator, null, null, accountService);
shoppingCartUpdatedEvent.Publish(null);
Assert.AreEqual(99, target.ItemCount);
shoppingCartRepository.GetShoppingCartAsyncDelegate = () => Task.FromResult <ShoppingCart>(null);
shoppingCartUpdatedEvent.Publish(null);
Assert.AreEqual(0, target.ItemCount);
}
public async Task AccountController_Login_Unsuccessful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockLoginUserAsync(false);
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var loginViewModel = new ViewModel.Login
{
Email = "*****@*****.**",
Password = "******",
ReturnUrl = null
};
var result = await accountController.Login(loginViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.Login>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.Login>(model);
Assert.Equal("Invalid email address or password", model.ErrorMessage);
}
public async Task AccountController_EditProfile_Unsuccessful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockUpdateUserProfileAsync(false);
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var editProfileViewModel = new ViewModel.EditProfile
{
Name = "James Doe",
Email = "*****@*****.**"
};
var result = await accountController.EditProfile(editProfileViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.EditProfile>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.EditProfile>(model);
Assert.Equal("Error updating user profile", model.ErrorMessage);
Assert.Equal("", model.SuccessMessage);
}
public async Task AccountController_Register_Unsuccessful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockRegisterUserAsync(false);
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var registerViewModel = new ViewModel.Register
{
Name = "Test User",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var result = (ViewResult)await accountController.Register(registerViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.Register>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.Register>(model);
}
public void SignOut_CallsSignOutinAccountServiceAndRemovesSavedCredentials()
{
bool closeFlyoutCalled = false;
bool accountServiceSignOutCalled = false;
bool clearHistoryCalled = false;
bool navigateCalled = false;
var accountService = new MockAccountService
{
SignOutDelegate = () => accountServiceSignOutCalled = true,
VerifyUserAuthenticationAsyncDelegate = () => Task.FromResult(new UserInfo())
};
var navigationService = new MockNavigationService
{
ClearHistoryDelegate = () => clearHistoryCalled = true,
NavigateDelegate = (s, o) =>
{
navigateCalled = true;
Assert.AreEqual("Hub", s);
return(true);
}
};
var target = new SignOutFlyoutViewModel(accountService, navigationService)
{
CloseFlyout = () => closeFlyoutCalled = true
};
target.SignOutCommand.Execute();
Assert.IsTrue(accountServiceSignOutCalled);
Assert.IsTrue(closeFlyoutCalled);
Assert.IsTrue(clearHistoryCalled);
Assert.IsTrue(navigateCalled);
}
public async Task AccountController_ChangePassword_Successful()
{
var mockLogger = Mock.Of <ILogger <AccountController> >();
var mockUserProvider = Mock.Of <IUserProvider>();
var mockAccountService = new MockAccountService().MockChangeUserPasswordAsync(true);
var accountController = new AccountController(mockUserProvider, mockAccountService.Object, mockLogger);
var changePasswordViewModel = new ViewModel.ChangePassword
{
CurrentPassword = "******",
Password = "******",
ConfirmPassword = "******"
};
var result = await accountController.ChangePassword(changePasswordViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.ChangePassword>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.ChangePassword>(model);
Assert.Equal("Password changed successfully", model.SuccessMessage);
Assert.Equal("", model.ErrorMessage);
}
