public async Task WhenUserIsNotMember_ReturnsNonSuccess()
{
// Arrange
var controller = GetController();
var account = GetAccount(controller);
controller.SetCurrentUser(Fakes.User);
// Act
var result = await InvokeConfirm(controller, account);
// Assert
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.True(model.WrongUsername);
Assert.False(model.SuccessfulConfirmation);
}
public virtual async Task WhenAlreadyConfirmed_DoesNotSendEmail(Func <Fakes, User> getCurrentUser)
{
// Arrange
var controller = GetController();
var account = GetAccount(controller);
// Act
var result = await InvokeConfirmationRequiredPostAsync(controller, account, getCurrentUser);
// Assert
var mailService = GetMock <IMessageService>();
mailService.Verify(m => m.SendMessageAsync(It.IsAny <NewAccountMessage>(), It.IsAny <bool>(), It.IsAny <bool>()), Times.Never);
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.SentEmail);
}
public async Task WhenIsNotConfirmedAndTokenDoesNotMatch_ShowsError(Func <Fakes, User> getCurrentUser)
{
// Arrange
var controller = GetController();
var account = GetAccount(controller);
account.EmailConfirmationToken = "token";
account.UnconfirmedEmailAddress = "*****@*****.**";
// Act
var result = await InvokeConfirm(controller, account, getCurrentUser, "wrongToken");
// Assert
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.SuccessfulConfirmation);
}
public virtual void WhenAccountAlreadyConfirmed()
{
// Arrange
var controller = GetController();
var account = GetAccount(controller);
controller.SetCurrentUser(GetCurrentUser(controller));
// Act
var result = InvokeConfirmationRequired(controller, account);
// Assert
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.True(model.AlreadyConfirmed);
Assert.Equal(account.EmailAddress, model.ConfirmedEmailAddress);
Assert.Null(model.UnconfirmedEmailAddress);
}
public async Task WhenIsNotConfirmedAndEntityExceptionThrown_ShowsErrorForDuplicateEmail(Func <Fakes, User> getCurrentUser)
{
// Arrange
var controller = GetController();
var account = GetAccount(controller);
var token = account.EmailConfirmationToken = "token";
account.UnconfirmedEmailAddress = "*****@*****.**";
// Act
var result = await InvokeConfirm(controller, account, getCurrentUser, token,
exception : new EntityException("msg"));
// Assert
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.SuccessfulConfirmation);
Assert.True(model.DuplicateEmailAddress);
}
public void WillReturnTheAccountViewModelWithTheUserApiKey()
{
var controller = GetController <UsersController>();
controller.SetUser("user");
var stubApiKey = Guid.NewGuid();
GetMock <IUserService>()
.Setup(s => s.FindByUsername("user"))
.Returns(new User {
Key = 42, ApiKey = stubApiKey
});
// act
var model = ResultAssert.IsView <AccountViewModel>(controller.Account());
// verify
Assert.Equal(stubApiKey.ToString(), model.ApiKey);
}
public async Task WhenAddOrganizationThrowsEntityException_ReturnsViewWithMessage()
{
var message = "message";
var mockUserService = GetMock <IUserService>();
mockUserService
.Setup(x => x.AddOrganizationAsync(OrgName, OrgEmail, Admin))
.Throws(new EntityException(message));
var controller = GetController <OrganizationsController>();
controller.SetCurrentUser(Admin);
var result = await controller.Add(Model);
ResultAssert.IsView <AddOrganizationViewModel>(result);
Assert.Equal(message, controller.TempData["ErrorMessage"]);
}
public virtual async Task WithNullUser_ShowsError(Func <Fakes, User> getCurrentUser)
{
// Arrange
var controller = GetController();
var accountUsername = "******";
controller.SetCurrentUser(getCurrentUser(Fakes));
// Act
var result = await controller.Confirm(accountUsername, "token");
// Assert
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.Equal(accountUsername, model.AccountName);
Assert.False(model.SuccessfulConfirmation);
Assert.True(model.WrongUsername);
Assert.True(model.AlreadyConfirmed);
}
public void WillReturnTheAccountViewModelWithTheCuratedFeeds()
{
var controller = GetController <UsersController>();
controller.SetCurrentUser(new User {
Key = 42
});
GetMock <ICuratedFeedService>()
.Setup(stub => stub.GetFeedsForManager(42))
.Returns(new[] { new CuratedFeed {
Name = "theCuratedFeed"
} });
// act
var model = ResultAssert.IsView <AccountViewModel>(controller.Account(), viewName: "Account");
// verify
Assert.Equal("theCuratedFeed", model.CuratedFeeds.First());
}
public virtual void WhenAccountIsNotConfirmed(Func <Fakes, User> getCurrentUser)
{
// Arrange
var controller = GetController();
var account = GetAccount(controller);
account.UnconfirmedEmailAddress = account.EmailAddress;
account.EmailAddress = null;
// Act
var result = InvokeConfirmationRequired(controller, account, getCurrentUser);
// Assert
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.AlreadyConfirmed);
Assert.Null(model.ConfirmedEmailAddress);
Assert.Equal(account.UnconfirmedEmailAddress, model.UnconfirmedEmailAddress);
}
public virtual void WhenAlreadyConfirmed_DoesNotSendEmail()
{
// Arrange
var controller = GetController();
var account = GetAccount(controller);
controller.SetCurrentUser(GetCurrentUser(controller));
// Act
var result = InvokeConfirmationRequiredPost(controller, account);
// Assert
var mailService = GetMock <IMessageService>();
mailService.Verify(m => m.SendNewAccountEmail(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.SentEmail);
}
public void WillReturnTheAccountViewModelWithTheCuratedFeeds(Func <Fakes, User> getCurrentUser)
{
// Arrange
var controller = GetController <TAccountsController>();
var account = GetAccount(controller);
GetMock <ICuratedFeedService>()
.Setup(stub => stub.GetFeedsForManager(account.Key))
.Returns(new[] { new CuratedFeed {
Name = "theCuratedFeed"
} });
// Act
var result = InvokeAccountInternal(controller, getCurrentUser);
// Assert
var model = ResultAssert.IsView <TAccountViewModel>(result, viewName: controller.AccountAction);
Assert.Equal("theCuratedFeed", model.CuratedFeeds.First());
}
public async Task ShowsAnErrorForWrongUsername()
{
var user = new User
{
Username = "******",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "aToken",
};
var controller = GetController <UsersController>();
controller.SetCurrentUser(user);
var result = await controller.Confirm("wrongUsername", "aToken");
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.SuccessfulConfirmation);
Assert.True(model.WrongUsername);
}
public async Task GivenFailureInAuthService_ItAddsModelError()
{
// Arrange
var user = new User("foo");
user.Credentials.Add(CredentialBuilder.CreatePbkdf2Password("old"));
GetMock <AuthenticationService>()
.Setup(u => u.ChangePassword(user, "old", "new", false))
.CompletesWith(false);
var controller = GetController <UsersController>();
controller.SetCurrentUser(user);
var inputModel = new AccountViewModel()
{
ChangePassword = new ChangePasswordViewModel()
{
OldPassword = "******",
NewPassword = "******",
}
};
// Act
var result = await controller.ChangePassword(inputModel);
// Assert
var outputModel = ResultAssert.IsView <AccountViewModel>(result, viewName: "Account");
Assert.Same(inputModel, outputModel);
var errorMessages = controller
.ModelState["ChangePassword.OldPassword"]
.Errors
.Select(e => e.ErrorMessage)
.ToArray();
Assert.Equal(errorMessages, new[] { Strings.CurrentPasswordIncorrect });
}
public void WillUseApiKeyInColumnIfNoCredentialPresent()
{
var apiKey = Guid.NewGuid();
var controller = GetController <UsersController>();
controller.SetCurrentUser(new User {
Key = 42, ApiKey = apiKey
});
GetMock <ICuratedFeedService>()
.Setup(stub => stub.GetFeedsForManager(42))
.Returns(new[] { new CuratedFeed {
Name = "theCuratedFeed"
} });
// act
var result = controller.Account();
// verify
var model = ResultAssert.IsView <AccountViewModel>(result);
Assert.Equal(apiKey.ToString().ToLowerInvariant(), model.ApiKey);
}
public async Task ShowsAnErrorForWrongToken()
{
var user = new User
{
Username = "******",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "aToken",
};
GetMock <IUserService>()
.Setup(u => u.ConfirmEmailAddress(user, It.IsAny <string>()))
.CompletesWith(false);
var controller = GetController <UsersController>();
controller.SetCurrentUser(user);
var result = await controller.Confirm("aUsername", "wrongToken");
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.SuccessfulConfirmation);
}
public async Task ShowsAnErrorForConflictingEmailAddress()
{
var user = new User
{
Username = "******",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "aToken",
};
GetMock <IUserService>()
.Setup(u => u.ConfirmEmailAddress(user, It.IsAny <string>()))
.Throws(new EntityException("msg"));
var controller = GetController <UsersController>();
controller.SetCurrentUser(user);
var result = await controller.Confirm("aUsername", "aToken");
var model = ResultAssert.IsView <ConfirmationViewModel>(result);
Assert.False(model.SuccessfulConfirmation);
Assert.True(model.DuplicateEmailAddress);
}
public async Task GivenInvalidView_ItReturnsView()
{
// Arrange
var controller = GetController <UsersController>();
controller.ModelState.AddModelError("ChangePassword.blarg", "test");
var inputModel = new AccountViewModel();
controller.SetCurrentUser(new User()
{
Credentials = new List <Credential> {
new CredentialBuilder().CreatePasswordCredential("abc")
}
});
// Act
var result = await controller.ChangePassword(inputModel);
// Assert
var outputModel = ResultAssert.IsView <AccountViewModel>(result, viewName: "Account");
Assert.Same(inputModel, outputModel);
}
public async Task DeleteHappyAccount(bool shouldUnlist)
{
// Arrange
string username = "******";
var controller = GetController();
var fakes = Get <Fakes>();
var testUser = fakes.CreateUser(username);
testUser.IsDeleted = false;
testUser.Key = 1;
var adminUser = fakes.Admin;
controller.SetCurrentUser(adminUser);
var expectedStatus = new DeleteAccountStatus();
GetMock <IDeleteAccountService>()
.Setup(stub => stub.DeleteAccountAsync(
testUser,
adminUser,
shouldUnlist ? AccountDeletionOrphanPackagePolicy.UnlistOrphans : AccountDeletionOrphanPackagePolicy.KeepOrphans))
.ReturnsAsync(expectedStatus);
var model = new DeleteAccountAsAdminViewModel()
{
AccountName = username,
ShouldUnlist = shouldUnlist
};
// act
var result = await controller.Delete(model);
var status = ResultAssert.IsView <DeleteAccountStatus>(result, "DeleteAccountStatus");
// Assert
Assert.Equal(expectedStatus, status);
}
public void UpdatesEmailAllowedSetting()
{
var user = new User("aUsername")
{
EmailAddress = "*****@*****.**",
EmailAllowed = true
};
var controller = GetController <UsersController>();
controller.SetCurrentUser(user);
GetMock <IUserService>()
.Setup(u => u.UpdateProfile(user, false));
var model = new EditProfileViewModel {
EmailAddress = "*****@*****.**", EmailAllowed = false
};
var result = controller.Edit(model);
var viewModel = ResultAssert.IsView <EditProfileViewModel>(result);
Assert.Same(model, viewModel);
GetMock <IUserService>().Verify(u => u.UpdateProfile(user, false));
}
public void LoadsDescriptionsOfCredentialsInToViewModel()
{
// Arrange
var user = Fakes.CreateUser(
"test",
CredentialBuilder.CreatePbkdf2Password("hunter2"),
CredentialBuilder.CreateV1ApiKey(Guid.NewGuid()),
CredentialBuilder.CreateExternalCredential("MicrosoftAccount", "blarg", "Bloog"));
var controller = GetController <UsersController>();
controller.SetCurrentUser(user);
// Act
var result = controller.Account();
// Assert
var model = ResultAssert.IsView <AccountViewModel>(result, viewName: "Account");
var descs = model.Credentials.ToDictionary(c => c.Kind); // Should only be one of each kind
Assert.Equal(3, descs.Count);
Assert.Equal(Strings.CredentialType_Password, descs[CredentialKind.Password].TypeCaption);
Assert.Equal(Strings.CredentialType_ApiKey, descs[CredentialKind.Token].TypeCaption);
Assert.Equal(Strings.MicrosoftAccount_Caption, descs[CredentialKind.External].TypeCaption);
}
