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); }