public void DoesNotSendEmailChangeConfirmationNoticeWhenTokenDoesNotChange()
{
var user = new User
{
EmailAddress = "*****@*****.**",
EmailAllowed = true,
EmailConfirmationToken = "token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny <string>()))
.Returns(user);
controller.MockMessageService
.Setup(m => m.SendEmailChangeConfirmationNotice(It.IsAny <MailAddress>(), It.IsAny <string>()))
.Throws(new InvalidOperationException());
var model = new EditProfileViewModel {
EmailAddress = "*****@*****.**", EmailAllowed = true
};
var result = controller.Edit(model) as RedirectToRouteResult;
Assert.NotNull(result);
Assert.Equal("Account settings saved!", controller.TempData["Message"]);
controller.MockUserService
.Verify(u => u.UpdateProfile(user, It.IsAny <string>(), true));
}
public void SendsEmailChangeConfirmationNoticeWhenEmailConfirmationTokenChanges()
{
var user = new User
{
EmailAddress = "*****@*****.**",
EmailAllowed = true
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny <string>()))
.Returns(user);
controller.MockUserService
.Setup(u => u.UpdateProfile(user, "*****@*****.**", true))
.Callback(() => user.EmailConfirmationToken = "token");
var model = new EditProfileViewModel {
EmailAddress = "*****@*****.**", EmailAllowed = true
};
var result = controller.Edit(model) as RedirectToRouteResult;
Assert.NotNull(result);
Assert.Equal(
"Account settings saved! We sent a confirmation email to verify your new email. When you confirm the email address, it will take effect and we will forget the old one.",
controller.TempData["Message"]);
}
public void DoesntSendAccountChangedEmailsIfConfirmationTokenDoesntMatch()
{
var user = new User
{
EmailAddress = "*****@*****.**",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "faketoken"))
.Returns(false);
// act:
var model = (controller.Confirm("username", "faketoken") as ViewResult).Model as EmailConfirmationModel;
// verify:
Assert.False(model.SuccessfulConfirmation);
Assert.False(model.ConfirmingNewAccount);
controller.MockMessageService
.Verify(m => m.SendEmailChangeConfirmationNotice(It.IsAny <MailAddress>(), It.IsAny <string>()), Times.Never());
controller.MockMessageService
.Verify(m => m.SendEmailChangeNoticeToPreviousEmailAddress(It.IsAny <User>(), It.IsAny <string>()), Times.Never());
}
public void UpdatesEmailAllowedSetting()
{
var user = new User
{
EmailAddress = "*****@*****.**",
EmailAllowed = true
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny <string>()))
.Returns(user);
controller.MockUserService
.Setup(u => u.UpdateProfile(user, "*****@*****.**", false))
.Verifiable();
var model = new EditProfileViewModel {
EmailAddress = "*****@*****.**", EmailAllowed = false
};
var result = controller.Edit(model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockUserService
.Verify(u => u.UpdateProfile(user, "*****@*****.**", false));
Assert.Equal("Account settings saved!", controller.TempData["Message"]);
}
public void SendsEmailWithPasswordResetUrl()
{
const string resetUrl = "https://example.org/?Controller=Users&Action=ResetPassword&username=somebody&token=confirmation";
var user = new User
{
EmailAddress = "*****@*****.**",
Username = "******",
PasswordResetToken = "confirmation",
PasswordResetTokenExpirationDate = DateTime.UtcNow.AddDays(1)
};
var controller = new TestableUsersController();
controller.MockMessageService
.Setup(s => s.SendPasswordResetInstructions(user, resetUrl));
controller.MockUserService
.Setup(s => s.GeneratePasswordResetToken("user", 1440))
.Returns(user);
var model = new ForgotPasswordViewModel {
Email = "user"
};
var result = controller.ForgotPassword(model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockMessageService
.Verify(s => s.SendPasswordResetInstructions(user, resetUrl));
}
public void Returns404WhenTokenIsEmpty()
{
var controller = new TestableUsersController();
var result = controller.Confirm("username", "") as HttpNotFoundResult;
Assert.NotNull(result);
}
public void WillGetTheCurrentUserUsingTheRequestIdentityName()
{
var controller = new TestableUsersController();
controller.StubIdentity.Setup(stub => stub.Name).Returns("theUsername");
controller.Account();
controller.StubUserByUsernameQry.Verify(stub => stub.Execute("theUsername", true));
}
public void WillShowTheViewWithErrorsIfTheModelStateIsInvalid()
{
var controller = new TestableUsersController();
controller.ModelState.AddModelError(String.Empty, "aFakeError");
var result = controller.Register(null) as ViewResult;
Assert.NotNull(result);
Assert.Empty(result.ViewName);
}
public void WithInvalidUsernameReturnsFileNotFound()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny <string>()))
.ReturnsNull();
var result = controller.Edit(new EditProfileViewModel()) as HttpNotFoundResult;
Assert.NotNull(result);
}
public void GeneratesAnApiKey()
{
var controller = new TestableUsersController();
controller.MockCurrentIdentity
.Setup(i => i.Name)
.Returns("the-username");
controller.GenerateApiKey();
controller.MockUserService
.Verify(s => s.GenerateApiKey("the-username"));
}
public void ShowsDefaultThanksViewWhenConfirmingEmailAddressIsRequired()
{
var controller = new TestableUsersController();
controller.MockConfig
.Setup(x => x.ConfirmEmailAddresses)
.Returns(true);
var result = controller.Thanks() as ViewResult;
Assert.Empty(result.ViewName);
Assert.Null(result.Model);
}
public void WillGetCuratedFeedsManagedByTheCurrentUser()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny<string>()))
.Returns(new User { Key = 42 });
// act
controller.Account();
// verify
controller.MockCuratedFeedService
.Verify(query => query.GetFeedsForManager(42));
}
public void RedirectsToAccountPage()
{
var controller = new TestableUsersController();
controller.MockCurrentIdentity
.Setup(i => i.Name)
.Returns("the-username");
var result = controller.GenerateApiKey() as RedirectToRouteResult;
Assert.NotNull(result);
Assert.Equal("Account", result.RouteValues["action"]);
Assert.Equal("Users", result.RouteValues["controller"]);
}
public void WillReturnTheAccountViewModelWithTheUserApiKey()
{
var stubApiKey = Guid.NewGuid();
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny<string>()))
.Returns(new User { Key = 42, ApiKey = stubApiKey });
// act
var model = ((ViewResult)controller.Account()).Model as AccountViewModel;
// verify
Assert.Equal(stubApiKey.ToString(), model.ApiKey);
}
public void WillReturnTheAccountViewModelWithTheCuratedFeeds()
{
var controller = new TestableUsersController();
controller.StubCuratedFeedsByManagerQry
.Setup(stub => stub.Execute(It.IsAny <int>()))
.Returns(new[] { new CuratedFeed {
Name = "theCuratedFeed"
} });
var model = ((ViewResult)controller.Account()).Model as AccountViewModel;
Assert.Equal("theCuratedFeed", model.CuratedFeeds.First());
}
public void WillGetCuratedFeedsManagedByTheCurrentUser()
{
var controller = new TestableUsersController();
controller.StubUserByUsernameQry
.Setup(stub => stub.Execute(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(new User {
Key = 42
});
controller.Account();
controller.StubCuratedFeedsByManagerQry.Verify(stub => stub.Execute(42));
}
public void WillReturnTheAccountViewModelWithTheUserApiKey()
{
var controller = new TestableUsersController();
var stubApiKey = Guid.NewGuid();
controller.StubUserByUsernameQry
.Setup(stub => stub.Execute(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(new User {
Key = 42, ApiKey = stubApiKey
});
var model = ((ViewResult)controller.Account()).Model as AccountViewModel;
Assert.Equal(stubApiKey.ToString(), model.ApiKey);
}
public void WillReturnTheAccountViewModelWithTheCuratedFeeds()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny<string>()))
.Returns(new User { Key = 42 });
controller.MockCuratedFeedService
.Setup(stub => stub.GetFeedsForManager(It.IsAny<int>()))
.Returns(new[] { new CuratedFeed { Name = "theCuratedFeed" } });
// act
var model = ((ViewResult)controller.Account()).Model as AccountViewModel;
// verify
Assert.Equal("theCuratedFeed", model.CuratedFeeds.First());
}
public void ShowsConfirmViewWithModelWhenConfirmingEmailAddressIsNotRequired()
{
var controller = new TestableUsersController();
controller.MockConfig
.Setup(x => x.ConfirmEmailAddresses)
.Returns(false);
var result = controller.Thanks() as ViewResult;
Assert.Equal("Confirm", result.ViewName);
var model = result.Model as EmailConfirmationModel;
Assert.True(model.ConfirmingNewAccount);
Assert.True(model.SuccessfulConfirmation);
}
public void ReturnsSameViewIfTokenGenerationFails()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.GeneratePasswordResetToken("user", 1440))
.Returns((User)null);
var model = new ForgotPasswordViewModel {
Email = "user"
};
var result = controller.ForgotPassword(model) as ViewResult;
Assert.NotNull(result);
Assert.IsNotType(typeof(RedirectResult), result);
}
public void WillGetTheCurrentUserUsingTheRequestIdentityName()
{
var controller = new TestableUsersController();
controller.MockCurrentIdentity
.Setup(stub => stub.Name)
.Returns("theUsername");
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny<string>()))
.Returns(new User { Key = 42 });
//act
controller.Account();
// verify
controller.MockUserService
.Verify(stub => stub.FindByUsername("theUsername"));
}
public void WillReturnTheAccountViewModelWithTheUserApiKey()
{
var stubApiKey = Guid.NewGuid();
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny <string>()))
.Returns(new User {
Key = 42, ApiKey = stubApiKey
});
// act
var model = ((ViewResult)controller.Account()).Model as AccountViewModel;
// verify
Assert.Equal(stubApiKey.ToString(), model.ApiKey);
}
public void WillGetCuratedFeedsManagedByTheCurrentUser()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny <string>()))
.Returns(new User {
Key = 42
});
// act
controller.Account();
// verify
controller.MockFeedsQuery
.Verify(query => query.Execute(42));
}
public void ResetsPasswordForValidToken()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(true);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = controller.ResetPassword("user", "token", model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockUserService
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void ShowsErrorIfTokenExpired()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(false);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
controller.ResetPassword("user", "token", model);
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
controller.MockUserService
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void ReturnsConfirmedWhenTokenMatchesUser()
{
var user = new User
{
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "the-token"))
.Returns(true);
var model = (controller.Confirm("username", "the-token") as ViewResult).Model as EmailConfirmationModel;
Assert.True(model.SuccessfulConfirmation);
}
public void WillGetTheCurrentUserUsingTheRequestIdentityName()
{
var controller = new TestableUsersController();
controller.MockCurrentIdentity
.Setup(stub => stub.Name)
.Returns("theUsername");
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny <string>()))
.Returns(new User {
Key = 42
});
//act
controller.Account();
// verify
controller.MockUserService
.Verify(stub => stub.FindByUsername("theUsername"));
}
public void WillReturnTheAccountViewModelWithTheCuratedFeeds()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.FindByUsername(It.IsAny <string>()))
.Returns(new User {
Key = 42
});
controller.MockFeedsQuery
.Setup(stub => stub.Execute(It.IsAny <int>()))
.Returns(new[] { new CuratedFeed {
Name = "theCuratedFeed"
} });
// act
var model = ((ViewResult)controller.Account()).Model as AccountViewModel;
// verify
Assert.Equal("theCuratedFeed", model.CuratedFeeds.First());
}
public void WillCreateTheUser()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(x => x.Create(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(new User {
Username = "******", EmailAddress = "*****@*****.**"
});
controller.Register(
new RegisterRequest
{
Username = "******",
Password = "******",
EmailAddress = "theEmailAddress",
});
controller.MockUserService
.Verify(x => x.Create("theUsername", "thePassword", "theEmailAddress"));
}
public void ReturnsFalseWhenTokenDoesNotMatchUser()
{
var user = new User
{
EmailAddress = "*****@*****.**",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "not-the-token"))
.Returns(false);
var model = (controller.Confirm("username", "not-the-token") as ViewResult).Model as EmailConfirmationModel;
Assert.False(model.SuccessfulConfirmation);
}
public void WillInvalidateModelStateAndShowTheViewWhenAnEntityExceptionIsThrow()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(x => x.Create(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Throws(new EntityException("aMessage"));
var result = controller.Register(
new RegisterRequest
{
Username = "******",
Password = "******",
EmailAddress = "theEmailAddress",
}) as ViewResult;
Assert.NotNull(result);
Assert.Empty(result.ViewName);
Assert.False(controller.ModelState.IsValid);
Assert.Equal("aMessage", controller.ModelState[String.Empty].Errors[0].ErrorMessage);
}
public void RedirectsAfterGeneratingToken()
{
var user = new User {
EmailAddress = "*****@*****.**", Username = "******"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.GeneratePasswordResetToken("user", 1440))
.Returns(user)
.Verifiable();
var model = new ForgotPasswordViewModel {
Email = "user"
};
var result = controller.ForgotPassword(model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockUserService
.Verify(s => s.GeneratePasswordResetToken("user", 1440));
}
public void WillSendNewUserEmailIfConfirmationRequired()
{
string sentConfirmationUrl = null;
MailAddress sentToAddress = null;
var controller = new TestableUsersController();
controller.MockMessageService
.Setup(m => m.SendNewAccountEmail(It.IsAny <MailAddress>(), It.IsAny <string>()))
.Callback <MailAddress, string>((to, url) =>
{
sentToAddress = to;
sentConfirmationUrl = url;
});
controller.MockUserService
.Setup(x => x.Create(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(new User
{
Username = "******",
EmailAddress = "*****@*****.**",
EmailConfirmationToken = "confirmation"
});
controller.MockConfig
.Setup(x => x.ConfirmEmailAddresses)
.Returns(true);
controller.Register(
new RegisterRequest
{
Username = "******",
Password = "******",
EmailAddress = "*****@*****.**",
});
// We use a catch-all route for unit tests so we can see the parameters
// are passed correctly.
Assert.Equal("https://example.org/?Controller=Users&Action=Confirm&username=theUsername&token=confirmation", sentConfirmationUrl);
Assert.Equal("*****@*****.**", sentToAddress.Address);
}
public void SendsAccountChangedNoticeWhenConfirmingChangedEmail()
{
var user = new User
{
EmailAddress = "*****@*****.**",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "the-token"))
.Returns(true);
var model = (controller.Confirm("username", "the-token") as ViewResult).Model as EmailConfirmationModel;
Assert.True(model.SuccessfulConfirmation);
Assert.False(model.ConfirmingNewAccount);
controller.MockMessageService
.Verify(m => m.SendEmailChangeNoticeToPreviousEmailAddress(user, "*****@*****.**"));
}
public void ResetsPasswordForValidToken()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(true);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
var result = controller.ResetPassword("user", "token", model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockUserService
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void DoesNotSendEmailChangeConfirmationNoticeWhenTokenDoesNotChange()
{
var user = new User
{
EmailAddress = "*****@*****.**",
EmailAllowed = true,
EmailConfirmationToken = "token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny<string>()))
.Returns(user);
controller.MockMessageService
.Setup(m => m.SendEmailChangeConfirmationNotice(It.IsAny<MailAddress>(), It.IsAny<string>()))
.Throws(new InvalidOperationException());
var model = new EditProfileViewModel { EmailAddress = "*****@*****.**", EmailAllowed = true };
var result = controller.Edit(model) as RedirectToRouteResult;
Assert.NotNull(result);
Assert.Equal("Account settings saved!", controller.TempData["Message"]);
controller.MockUserService
.Verify(u => u.UpdateProfile(user, It.IsAny<string>(), true));
}
public void WithInvalidUsernameReturnsFileNotFound()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny<string>()))
.ReturnsNull();
var result = controller.Edit(new EditProfileViewModel()) as HttpNotFoundResult;
Assert.NotNull(result);
}
public void SendsEmailWithPasswordResetUrl()
{
const string resetUrl = "https://example.org/?Controller=Users&Action=ResetPassword&username=somebody&token=confirmation";
var user = new User
{
EmailAddress = "*****@*****.**",
Username = "******",
PasswordResetToken = "confirmation",
PasswordResetTokenExpirationDate = DateTime.UtcNow.AddDays(1)
};
var controller = new TestableUsersController();
controller.MockMessageService
.Setup(s => s.SendPasswordResetInstructions(user, resetUrl));
controller.MockUserService
.Setup(s => s.GeneratePasswordResetToken("user", 1440))
.Returns(user);
var model = new ForgotPasswordViewModel { Email = "user" };
var result = controller.ForgotPassword(model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockMessageService
.Verify(s => s.SendPasswordResetInstructions(user, resetUrl));
}
public void RedirectsAfterGeneratingToken()
{
var user = new User { EmailAddress = "*****@*****.**", Username = "******" };
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.GeneratePasswordResetToken("user", 1440))
.Returns(user)
.Verifiable();
var model = new ForgotPasswordViewModel { Email = "user" };
var result = controller.ForgotPassword(model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockUserService
.Verify(s => s.GeneratePasswordResetToken("user", 1440));
}
public void ReturnsConfirmedWhenTokenMatchesUser()
{
var user = new User
{
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "the-token"))
.Returns(true);
var model = (controller.Confirm("username", "the-token") as ViewResult).Model as EmailConfirmationModel;
Assert.True(model.SuccessfulConfirmation);
}
public void WillSendNewUserEmailIfConfirmationRequired()
{
string sentConfirmationUrl = null;
MailAddress sentToAddress = null;
var controller = new TestableUsersController();
controller.MockMessageService
.Setup(m => m.SendNewAccountEmail(It.IsAny<MailAddress>(), It.IsAny<string>()))
.Callback<MailAddress, string>((to, url) =>
{
sentToAddress = to;
sentConfirmationUrl = url;
});
controller.MockUserService
.Setup(x => x.Create(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
.Returns(new User
{
Username = "******",
EmailAddress = "*****@*****.**",
EmailConfirmationToken = "confirmation"
});
controller.MockConfig
.Setup(x => x.ConfirmEmailAddresses)
.Returns(true);
controller.Register(
new RegisterRequest
{
Username = "******",
Password = "******",
EmailAddress = "*****@*****.**",
});
// We use a catch-all route for unit tests so we can see the parameters
// are passed correctly.
Assert.Equal("https://example.org/?Controller=Users&Action=Confirm&username=theUsername&token=confirmation", sentConfirmationUrl);
Assert.Equal("*****@*****.**", sentToAddress.Address);
}
public void ReturnsFalseWhenTokenDoesNotMatchUser()
{
var user = new User
{
EmailAddress = "*****@*****.**",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "not-the-token"))
.Returns(false);
var model = (controller.Confirm("username", "not-the-token") as ViewResult).Model as EmailConfirmationModel;
Assert.False(model.SuccessfulConfirmation);
}
public void SendsEmailChangeConfirmationNoticeWhenEmailConfirmationTokenChanges()
{
var user = new User
{
EmailAddress = "*****@*****.**",
EmailAllowed = true
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny<string>()))
.Returns(user);
controller.MockUserService
.Setup(u => u.UpdateProfile(user, "*****@*****.**", true))
.Callback(() => user.EmailConfirmationToken = "token");
var model = new EditProfileViewModel { EmailAddress = "*****@*****.**", EmailAllowed = true };
var result = controller.Edit(model) as RedirectToRouteResult;
Assert.NotNull(result);
Assert.Equal(
"Account settings saved! We sent a confirmation email to verify your new email. When you confirm the email address, it will take effect and we will forget the old one.",
controller.TempData["Message"]);
}
public void WillShowTheViewWithErrorsIfTheModelStateIsInvalid()
{
var controller = new TestableUsersController();
controller.ModelState.AddModelError(String.Empty, "aFakeError");
var result = controller.Register(null) as ViewResult;
Assert.NotNull(result);
Assert.Empty(result.ViewName);
}
public void WillCreateTheUser()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(x => x.Create(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
.Returns(new User { Username = "******", EmailAddress = "*****@*****.**" });
controller.Register(
new RegisterRequest
{
Username = "******",
Password = "******",
EmailAddress = "theEmailAddress",
});
controller.MockUserService
.Verify(x => x.Create("theUsername", "thePassword", "theEmailAddress"));
}
public void WillInvalidateModelStateAndShowTheViewWhenAnEntityExceptionIsThrow()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(x => x.Create(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
.Throws(new EntityException("aMessage"));
var result = controller.Register(
new RegisterRequest
{
Username = "******",
Password = "******",
EmailAddress = "theEmailAddress",
}) as ViewResult;
Assert.NotNull(result);
Assert.Empty(result.ViewName);
Assert.False(controller.ModelState.IsValid);
Assert.Equal("aMessage", controller.ModelState[String.Empty].Errors[0].ErrorMessage);
}
public void ShowsDefaultThanksViewWhenConfirmingEmailAddressIsRequired()
{
var controller = new TestableUsersController();
controller.MockConfig
.Setup(x => x.ConfirmEmailAddresses)
.Returns(true);
var result = controller.Thanks() as ViewResult;
Assert.Empty(result.ViewName);
Assert.Null(result.Model);
}
public void SendsAccountChangedNoticeWhenConfirmingChangedEmail()
{
var user = new User
{
EmailAddress = "*****@*****.**",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "the-token"))
.Returns(true);
var model = (controller.Confirm("username", "the-token") as ViewResult).Model as EmailConfirmationModel;
Assert.True(model.SuccessfulConfirmation);
Assert.False(model.ConfirmingNewAccount);
controller.MockMessageService
.Verify(m => m.SendEmailChangeNoticeToPreviousEmailAddress(user, "*****@*****.**"));
}
public void GeneratesAnApiKey()
{
var controller = new TestableUsersController();
controller.MockCurrentIdentity
.Setup(i => i.Name)
.Returns("the-username");
controller.GenerateApiKey();
controller.MockUserService
.Verify(s => s.GenerateApiKey("the-username"));
}
public void ShowsErrorIfTokenExpired()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.ResetPasswordWithToken("user", "token", "newpwd"))
.Returns(false);
var model = new PasswordResetViewModel
{
ConfirmPassword = "******",
NewPassword = "******"
};
controller.ResetPassword("user", "token", model);
Assert.Equal("The Password Reset Token is not valid or expired.", controller.ModelState[""].Errors[0].ErrorMessage);
controller.MockUserService
.Verify(u => u.ResetPasswordWithToken("user", "token", "newpwd"));
}
public void UpdatesEmailAllowedSetting()
{
var user = new User
{
EmailAddress = "*****@*****.**",
EmailAllowed = true
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername(It.IsAny<string>()))
.Returns(user);
controller.MockUserService
.Setup(u => u.UpdateProfile(user, "*****@*****.**", false))
.Verifiable();
var model = new EditProfileViewModel { EmailAddress = "*****@*****.**", EmailAllowed = false };
var result = controller.Edit(model) as RedirectToRouteResult;
Assert.NotNull(result);
controller.MockUserService
.Verify(u => u.UpdateProfile(user, "*****@*****.**", false));
Assert.Equal("Account settings saved!", controller.TempData["Message"]);
}
public void RedirectsToAccountPage()
{
var controller = new TestableUsersController();
controller.MockCurrentIdentity
.Setup(i => i.Name)
.Returns("the-username");
var result = controller.GenerateApiKey() as RedirectToRouteResult;
Assert.NotNull(result);
Assert.Equal("Account", result.RouteValues["action"]);
Assert.Equal("Users", result.RouteValues["controller"]);
}
public void DoesntSendAccountChangedEmailsIfConfirmationTokenDoesntMatch()
{
var user = new User
{
EmailAddress = "*****@*****.**",
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "the-token"
};
var controller = new TestableUsersController();
controller.MockUserService
.Setup(u => u.FindByUsername("username"))
.Returns(user);
controller.MockUserService
.Setup(u => u.ConfirmEmailAddress(user, "faketoken"))
.Returns(false);
// act:
var model = (controller.Confirm("username", "faketoken") as ViewResult).Model as EmailConfirmationModel;
// verify:
Assert.False(model.SuccessfulConfirmation);
Assert.False(model.ConfirmingNewAccount);
controller.MockMessageService
.Verify(m => m.SendEmailChangeConfirmationNotice(It.IsAny<MailAddress>(), It.IsAny<string>()), Times.Never());
controller.MockMessageService
.Verify(m => m.SendEmailChangeNoticeToPreviousEmailAddress(It.IsAny<User>(), It.IsAny<string>()), Times.Never());
}
public void ReturnsSameViewIfTokenGenerationFails()
{
var controller = new TestableUsersController();
controller.MockUserService
.Setup(s => s.GeneratePasswordResetToken("user", 1440))
.Returns((User)null);
var model = new ForgotPasswordViewModel { Email = "user" };
var result = controller.ForgotPassword(model) as ViewResult;
Assert.NotNull(result);
Assert.IsNotType(typeof(RedirectResult), result);
}
public void Returns404WhenTokenIsEmpty()
{
var controller = new TestableUsersController();
var result = controller.Confirm("username", "") as HttpNotFoundResult;
Assert.NotNull(result);
}
public void ShowsConfirmViewWithModelWhenConfirmingEmailAddressIsNotRequired()
{
var controller = new TestableUsersController();
controller.MockConfig
.Setup(x => x.ConfirmEmailAddresses)
.Returns(false);
var result = controller.Thanks() as ViewResult;
Assert.Equal("Confirm", result.ViewName);
var model = result.Model as EmailConfirmationModel;
Assert.True(model.ConfirmingNewAccount);
Assert.True(model.SuccessfulConfirmation);
}
