public static async Task SignInAsync_SuccessfulSignInWithNullContext_RaisesLoginSuccessEvent()
{
int eventCount = 0;
UserLoginSuccessEvent raisedEvent = null;
void EventCallback(UserLoginSuccessEvent evt)
{
eventCount++;
raisedEvent = evt;
}
const string userId = "UserId";
const string username = "******";
using var loginService = new LoginServiceBuilder()
.WithEventServiceCallback <UserLoginSuccessEvent>(EventCallback)
.WithSignInResult(IdentitySignInResult.Success)
.WithFindUserResult(ApplicationUserBuilder
.Create()
.WithUserId(userId)
.WithUsername(username)
.Build())
.Build();
await loginService.SignInAsync("user", "pass", new Uri("~/", UriKind.Relative));
eventCount.Should().Be(1);
Assert.NotNull(raisedEvent);
raisedEvent.ClientId.Should().BeNull();
raisedEvent.DisplayName.Should().Be(username);
raisedEvent.Message.Should().BeNull();
raisedEvent.SubjectId.Should().Be(userId);
raisedEvent.Username.Should().Be(username);
}
static void Test()
{
ApplicationUserBuilder
.Create()
.WithUsername(null)
.Build();
}
public async Task Login_NotValidUserData_ReturnsUnauthorized()
{
// Arrange
var loginRequest = new LoginRequestBuilder()
.WithPassword("pass12345")
.WithEmail("*****@*****.**")
.Build();
var user = new ApplicationUserBuilder()
.WithEmail(loginRequest.Email)
.WithUsername(loginRequest.Email)
.WithPassword(loginRequest.Password)
.WithId("abcd")
.Build();
var userManager = new Mock <MockUserManager>();
userManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
userManager.Setup(x => x.CheckPasswordAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.Returns(Task.FromResult(false));
var configurationMock = new Mock <IConfiguration>();
configurationMock.Setup(x => x[It.IsAny <string>()])
.Returns("SomeReallyLongAndSecretKey");
var accountController = new AccountController(userManager.Object, configurationMock.Object);
// Act
var result = await accountController.Login(loginRequest);
// Assert
result.Should().BeAssignableTo <BadRequestResult>();
}
private static (ApplicationUser RepoUser, OrganisationUserModel ExpectedUser) CreateApplicationUserTestData(
bool disabled)
{
var repositoryApplicationUser = ApplicationUserBuilder
.Create()
.WithFirstName(Guid.NewGuid().ToString())
.WithLastName(Guid.NewGuid().ToString())
.WithPhoneNumber(Guid.NewGuid().ToString())
.WithEmailAddress(Guid.NewGuid().ToString())
.WithDisabled(disabled)
.Build();
return(
RepoUser : repositoryApplicationUser,
ExpectedUser : new OrganisationUserModel
{
UserId = repositoryApplicationUser.Id,
EmailAddress = repositoryApplicationUser.Email,
PhoneNumber = repositoryApplicationUser.PhoneNumber,
FirstName = repositoryApplicationUser.FirstName,
LastName = repositoryApplicationUser.LastName,
IsDisabled = repositoryApplicationUser.Disabled
}
);
}
public async Task ValidateAsync_DuplicateEmailAddress_ReturnsFailure()
{
const string duplicateEmailAddress = "*****@*****.**";
var context = ApplicationUserValidatorTestContext.Setup();
context.ApplicationUserByEmail = ApplicationUserBuilder
.Create()
.WithEmailAddress(duplicateEmailAddress)
.Build();
var sut = context.ApplicationUserValidator;
var user = ApplicationUserBuilder
.Create()
.WithEmailAddress(duplicateEmailAddress)
.Build();
var actual = await sut.ValidateAsync(user);
var expected = Result.Failure(new List <ErrorDetails> {
new ErrorDetails("EmailAlreadyExists", "EmailAddress")
});
actual.Should().Be(expected);
}
public static async Task SignInAsync_FailedSignInWithNullContext_RaisesLoginFailureEvent()
{
const string username = "******";
int eventCount = 0;
UserLoginFailureEvent raisedEvent = null;
void EventCallback(UserLoginFailureEvent evt)
{
eventCount++;
raisedEvent = evt;
}
using var loginService = new LoginServiceBuilder()
.WithFindUserResult(ApplicationUserBuilder.Create().WithUsername(username).Build())
.WithEventServiceCallback <UserLoginFailureEvent>(EventCallback)
.WithSignInResult(IdentitySignInResult.Failed)
.Build();
await loginService.SignInAsync(username, "pass", null);
eventCount.Should().Be(1);
Assert.NotNull(raisedEvent);
raisedEvent.ClientId.Should().BeNull();
raisedEvent.Message.Should().Be(LoginService.ValidateUserMessage);
raisedEvent.Username.Should().Be(username);
}
public async Task GetFilteredBooks_UserHasOneCurrentlyReadingBook_ReturnsOneBook()
{
// Arrange
var tenDaysAgo = DateTime.Now.Subtract(new TimeSpan(10, 0, 0, 0));
var fiveDaysAgo = DateTime.Now.Subtract(new TimeSpan(5, 0, 0, 0));
var userOne = new ApplicationUserBuilder().WithId("1").Build();
var userTwo = new ApplicationUserBuilder().WithId("2").Build();
var data = new List <Book>
{
new BookBuilder().WithUser(userOne)
.WithReadingStart(tenDaysAgo)
.WithReadingEnd(fiveDaysAgo)
.Build(),
new BookBuilder().WithUser(userOne)
.WithReadingStart(tenDaysAgo)
.Build(),
new BookBuilder().WithUser(userTwo)
.WithReadingStart(tenDaysAgo)
.Build()
};
var dbset = GenerateEnumerableDbSetMock(data.AsQueryable());
var context = GenerateEnumerableContextMock(dbset);
var booksService = new BooksService(context.Object);
var filters = new BookFiltersBuilder()
.WithCurrentlyReadingStatus(true)
.Build();
// Act
var result = await booksService.GetFilteredBooks(userOne.Id, filters);
// Assert
result.Should().HaveCount(1);
}
public async Task GetFilteredBooks_UserHasTwoBooksWithYear_ReturnsTwoBooks()
{
// Arrange
var userOne = new ApplicationUserBuilder().WithId("1").Build();
var userTwo = new ApplicationUserBuilder().WithId("2").Build();
var data = new List <Book>
{
new BookBuilder().WithUser(userOne).WithYear(2015).Build(),
new BookBuilder().WithUser(userOne).WithYear(2010).Build(),
new BookBuilder().WithUser(userTwo).WithYear(2010).Build()
};
var dbset = GenerateEnumerableDbSetMock(data.AsQueryable());
var context = GenerateEnumerableContextMock(dbset);
var booksService = new BooksService(context.Object);
var filters = new BookFiltersBuilder()
.WithPublicationYearSince(2005)
.WithPublicationYearTo(2015)
.Build();
// Act
var result = await booksService.GetFilteredBooks(userOne.Id, filters);
// Assert
result.Should().HaveCount(2);
}
public static async Task GetProfileDataAsync_GivenAnApplicationUserExistsWithOrganisationFunctionBuyer_ReturnsExpectedClaimList()
{
var expectedApplicationUser = ApplicationUserBuilder
.Create()
.WithEmailAddress("*****@*****.**")
.WithFirstName("Bob")
.WithLastName("Smith")
.WithOrganisationFunction(OrganisationFunction.Buyer)
.Build();
Mock <IUsersRepository> applicationUserRepositoryMock = new Mock <IUsersRepository>();
applicationUserRepositoryMock
.Setup(r => r.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync(expectedApplicationUser);
var expectedOrganisation = OrganisationBuilder
.Create()
.Build();
Mock <IOrganisationRepository> organisationRepositoryMock = new Mock <IOrganisationRepository>();
organisationRepositoryMock
.Setup(r => r.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(expectedOrganisation);
var sut = ProfileServiceBuilder
.Create()
.WithUserRepository(applicationUserRepositoryMock.Object)
.WithOrganisationRepository(organisationRepositoryMock.Object)
.Build();
var profileDataRequestContext = ProfileDataRequestContextBuilder
.Create()
.WithSubjectId(expectedApplicationUser.Id)
.Build();
await sut.GetProfileDataAsync(profileDataRequestContext);
var expected = new List <(string, string)>
{
(Subject, expectedApplicationUser.Id),
(PreferredUserName, expectedApplicationUser.UserName),
(JwtRegisteredClaimNames.UniqueName, expectedApplicationUser.UserName),
(GivenName, expectedApplicationUser.FirstName),
(FamilyName, expectedApplicationUser.LastName),
(Name, $"{expectedApplicationUser.FirstName} {expectedApplicationUser.LastName}"),
(Email, expectedApplicationUser.Email),
(EmailVerified, expectedApplicationUser.EmailConfirmed.ToString(CultureInfo.CurrentCulture).ToLowerInvariant()),
(ApplicationClaimTypes.PrimaryOrganisationId, expectedApplicationUser.PrimaryOrganisationId.ToString()),
(ApplicationClaimTypes.PrimaryOrganisationName, expectedOrganisation.Name),
(ApplicationClaimTypes.OrganisationFunction, expectedApplicationUser.OrganisationFunction.DisplayName),
(ApplicationClaimTypes.Ordering, Manage),
(ApplicationClaimTypes.Organisation, View),
};
var actual = profileDataRequestContext.IssuedClaims.Select(item => (item.Type, item.Value));
actual.Should().BeEquivalentTo(expected);
}
public async Task GetUserConsentAsync_CatalogueAgreementNotSigned_ReturnsConsentWithNoScopes()
{
const string clientId = "SomeClient";
const string subjectId = "JulesVerneId";
var expectedConsent = new Consent
{
ClientId = clientId,
Expiration = DateTime.MaxValue,
Scopes = null,
SubjectId = subjectId,
};
var user = ApplicationUserBuilder.Create().Build();
var mockUsersRepository = new Mock <IUsersRepository>();
mockUsersRepository.Setup(
u => u.GetByIdAsync(It.Is <string>(s => s.Equals(subjectId, StringComparison.Ordinal))))
.ReturnsAsync(user);
var store = new CatalogueAgreementConsentStore(Mock.Of <IScopeRepository>(), mockUsersRepository.Object);
var actualConsent = await store.GetUserConsentAsync(subjectId, clientId);
actualConsent.Should().BeEquivalentTo(expectedConsent, o => o.Excluding(c => c.CreationTime));
}
public void NormalizedUserName_Trimmed()
{
var actual = ApplicationUserBuilder
.Create()
.WithUsername(" Test ")
.Build();
actual.NormalizedUserName.Should().Be("TEST");
}
public void NormalizedUserName_SetUserName_ReturnsNormalizedUserName(string input, string expected)
{
var actual = ApplicationUserBuilder
.Create()
.WithUsername(input)
.Build();
actual.NormalizedUserName.Should().Be(expected);
}
public void LastName_Trimmed()
{
var actual = ApplicationUserBuilder
.Create()
.WithLastName(" Smith ")
.Build();
actual.LastName.Should().Be("Smith");
}
public void PhoneNumber_Trimmed()
{
var actual = ApplicationUserBuilder
.Create()
.WithPhoneNumber(" 0123456 ")
.Build();
actual.PhoneNumber.Should().Be("0123456");
}
public void NormalizedEmail_SetEmail_ReturnsNormalizedEmail(string input, string expected)
{
var actual = ApplicationUserBuilder
.Create()
.WithEmailAddress(input)
.Build();
actual.NormalizedEmail.Should().Be(expected);
}
public void EmailAddress_Trimmed()
{
var actual = ApplicationUserBuilder
.Create()
.WithEmailAddress(" [email protected] ")
.Build();
actual.Email.Should().Be("*****@*****.**");
}
public void FirstName_Trimmed()
{
var actual = ApplicationUserBuilder
.Create()
.WithFirstName(" Dan ")
.Build();
actual.FirstName.Should().Be("Dan");
}
public static void UserName_Trimmed()
{
var actual = ApplicationUserBuilder
.Create()
.WithUsername(" Test ")
.Build();
actual.UserName.Should().Be("Test");
}
public static void Constructor_String_ApplicationUser_InitializesExpectedMembers()
{
const string expectedToken = "TokenToken";
var expectedUser = ApplicationUserBuilder.Create().Build();
var token = new PasswordResetToken(expectedToken, expectedUser);
token.Token.Should().Be(expectedToken);
token.User.Should().Be(expectedUser);
}
public void DisplayName_ReturnsExpectedValue()
{
var actual = ApplicationUserBuilder
.Create()
.WithFirstName("Burt")
.WithLastName("Reynolds")
.Build();
actual.DisplayName.Should().Be("Burt Reynolds");
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
var postBuilder = new PostBuilder(builder.Entity <Post>());
var pageBuilder = new PageBuilder(builder.Entity <Page>());
var categoryBuilder = new CategoryBuilder(builder.Entity <Category>());
var feedbackBuilder = new FeedbackBuilder(builder.Entity <Feedback>());
var applicationUserBuilder = new ApplicationUserBuilder(builder.Entity <ApplicationUser>());
}
public void MarkAsDisabled_DisabledIsTrue()
{
var actual = ApplicationUserBuilder
.Create()
.WithDisabled(false)
.Build();
actual.MarkAsDisabled();
actual.Disabled.Should().BeTrue();
}
public void MarkCatalogueAgreementAsSigned_CatalogueAgreementSignedIsTrue()
{
var actual = ApplicationUserBuilder
.Create()
.WithCatalogueAgreementSigned(false)
.Build();
actual.MarkCatalogueAgreementAsSigned();
actual.CatalogueAgreementSigned.Should().BeTrue();
}
public static async Task DisableUser_UserRepository_UpdateAsync_CalledOnce()
{
var context = UsersControllerTestContext.Setup();
var controller = context.Controller;
context.User = ApplicationUserBuilder.Create().WithDisabled(false).Build();
await controller.DisableUserAsync(context.User.Id);
context.UsersRepositoryMock.Verify(r => r.GetByIdAsync(context.User.Id));
context.UsersRepositoryMock.Verify(r => r.UpdateAsync(context.User));
}
public async Task EnableUserAsync_UserRepository_UpdateAsync_CalledOnce()
{
var context = UsersControllerTestContext.Setup();
using var controller = context.Controller;
context.User = ApplicationUserBuilder.Create().WithDisabled(true).Build();
await controller.EnableUserAsync(context.User.Id);
context.UsersRepositoryMock.Verify(x => x.GetByIdAsync(context.User.Id), Times.Once);
context.UsersRepositoryMock.Verify(x => x.UpdateAsync(context.User), Times.Once);
}
public async Task ValidateAsync_ValidApplicationUser_ReturnsSuccess()
{
var context = ApplicationUserValidatorTestContext.Setup();
var sut = context.ApplicationUserValidator;
var user = ApplicationUserBuilder
.Create()
.Build();
var actual = await sut.ValidateAsync(user);
actual.Should().Be(Result.Success());
}
public async Task GetProfileDataAsync_GivenAnApplicationUserWithTheName_ReturnsExpectedClaimList(
string firstname,
string lastname,
string expectedName)
{
var expectedApplicationUser = ApplicationUserBuilder
.Create()
.WithFirstName(firstname)
.WithLastName(lastname)
.Build();
Mock <IUsersRepository> applicationUserRepositoryMock = new Mock <IUsersRepository>();
applicationUserRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync(expectedApplicationUser);
var expectedOrganisation = OrganisationBuilder
.Create()
.Build();
Mock <IOrganisationRepository> organisationRespositoryMock = new Mock <IOrganisationRepository>();
organisationRespositoryMock.Setup(r => r.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(expectedOrganisation);
var sut = ProfileServiceBuilder
.Create()
.WithUserRepository(applicationUserRepositoryMock.Object)
.WithOrganisationRepository(organisationRespositoryMock.Object)
.Build();
var profileDataRequestContext = ProfileDataRequestContextBuilder
.Create()
.WithSubjectId(expectedApplicationUser.Id)
.Build();
await sut.GetProfileDataAsync(profileDataRequestContext);
var expected = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(Name, expectedName),
};
var actual = profileDataRequestContext.IssuedClaims
.Where(item => Name.Equals(item.Type, StringComparison.Ordinal))
.Select(item => new KeyValuePair <string, string>(item.Type, item.Value));
actual.Should().BeEquivalentTo(expected);
}
public async Task StoreUserConsentAsync_UpdatesRepository()
{
var user = ApplicationUserBuilder.Create().Build();
var mockUsersRepository = new Mock <IUsersRepository>();
mockUsersRepository.Setup(u => u.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync(user);
var store = new CatalogueAgreementConsentStore(Mock.Of <IScopeRepository>(), mockUsersRepository.Object);
await store.StoreUserConsentAsync(new Consent());
mockUsersRepository.Verify(r => r.UpdateAsync(It.Is <ApplicationUser>(u => u == user)), Times.Once());
}
public static void GetPasswordResetCallback_ReturnsExpectedValue()
{
const string url = "https://nhs.uk/reset";
var expectedUri = new Uri(url);
var context = new PasswordResetCallbackContext(url);
var callback = context.Callback;
var actualUri = callback.GetPasswordResetCallback(
new PasswordResetToken("Token", ApplicationUserBuilder.Create().Build()));
actualUri.Should().Be(expectedUri);
}
public static async Task DisableUserAsync_GetUserByIdAndDisableThem_ReturnsOk()
{
var context = UsersControllerTestContext.Setup();
var controller = context.Controller;
context.User = ApplicationUserBuilder.Create().WithDisabled(false).Build();
var result = await controller.DisableUserAsync(context.User.Id);
result.Should().BeOfType <NoContentResult>();
context.User.Disabled.Should().BeTrue();
}
