public async Task WhenSomeEmailAddressesAreInvalid_ItShouldCallUpdateFreeAccessUsersAndItShouldReturnValidEmailAddresses()
{
var emailList = new List <string> {
"*****@*****.**", "two.test.com"
};
var freeAccessUsersData = new FreeAccessUsersData {
Emails = emailList
};
var validEmailList = new List <ValidEmail> {
ValidEmail.Parse(emailList[0])
};
var invalidEmailList = new List <Email> {
new Email(emailList[1])
};
var expectedResult = new PutFreeAccessUsersResult(invalidEmailList);
this.updateFreeAccessUsers
.Setup(v => v.HandleAsync(new UpdateFreeAccessUsersCommand(Requester, BlogId, validEmailList)))
.Returns(Task.FromResult(0))
.Verifiable();
var result = await this.target.PutFreeAccessList(BlogId.Value.EncodeGuid(), freeAccessUsersData);
this.updateFreeAccessUsers.Verify();
Assert.AreEqual(expectedResult, result);
}
public async Task WhenUpdateAccountSettingsCalledWithSameEMailAndEmailWasNotConfirmed_ItShouldStillNotBeConfirmed()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UpdateAccountSettingsDbStatement(testDatabase, this.userManager.Object, this.requestSnapshot);
await this.CreateUserAsync(testDatabase, false);
await testDatabase.TakeSnapshotAsync();
var expectedUser = await this.GetUserAsync(testDatabase);
expectedUser.UserName = this.newUsername.Value;
expectedUser.ProfileImageFileId = this.newFileId.Value;
expectedUser.SecurityStamp = this.securityStamp;
var result = await this.target.ExecuteAsync(
this.userId,
this.newUsername,
ValidEmail.Parse(this.email.Value),
null,
this.newFileId,
this.securityStamp);
Assert.AreEqual(false, result.EmailConfirmed);
return(new ExpectedSideEffects
{
Update = expectedUser
});
});
}
public async Task WhenNewEmailList_AndEmailsForBlogIsEmpty_ItShouldModifyEmailsForBlog()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UpdateFreeAccessUsersDbStatement(testDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase, false);
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(
CreatorId,
BlogId,
new List <ValidEmail>
{
ValidEmail.Parse("*****@*****.**"),
ValidEmail.Parse("*****@*****.**")
});
return(new ExpectedSideEffects
{
Inserts = new List <FreeAccessUser>
{
new FreeAccessUser {
BlogId = BlogId.Value, Email = "*****@*****.**"
},
new FreeAccessUser {
BlogId = BlogId.Value, Email = "*****@*****.**"
},
},
});
});
}
public async Task ItShouldBeIdempotent()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UpdateFreeAccessUsersDbStatement(testDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase, true);
await this.target.ExecuteAsync(
CreatorId,
BlogId,
new List <ValidEmail>
{
ValidEmail.Parse("*****@*****.**"),
ValidEmail.Parse("*****@*****.**"),
ValidEmail.Parse("*****@*****.**")
});
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(
CreatorId,
BlogId,
new List <ValidEmail>
{
ValidEmail.Parse("*****@*****.**"),
ValidEmail.Parse("*****@*****.**"),
ValidEmail.Parse("*****@*****.**")
});
return(ExpectedSideEffects.None);
});
}
public async Task WhenNewEmailListIsSubset_ItShouldDeleteOldEmailsForBlog()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UpdateFreeAccessUsersDbStatement(testDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase, true);
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(
CreatorId,
BlogId,
new List <ValidEmail>
{
ValidEmail.Parse("*****@*****.**"),
});
return(new ExpectedSideEffects
{
Deletes = new List <FreeAccessUser>
{
new FreeAccessUser {
BlogId = BlogId.Value, Email = "*****@*****.**"
},
new FreeAccessUser {
BlogId = BlogId.Value, Email = "*****@*****.**"
},
},
});
});
}
public async Task WhenEmailDoesNotExist_ItShouldDoNothing()
{
var command = new RequestPasswordResetCommand(ValidEmail.Parse(EmailAddress), null);
this.userManager.Setup(_ => _.FindByEmailAsync(EmailAddress)).ReturnsAsync(null);
await this.target.HandleAsync(command);
}
public async Task WhenEmailExists_ItShouldSendEmail()
{
var command = new RequestPasswordResetCommand(ValidEmail.Parse(EmailAddress), null);
this.userManager.Setup(_ => _.FindByEmailAsync(EmailAddress)).ReturnsAsync(new FifthweekUser()
{
Id = UserId,
UserName = Username
});
await this.AssertEmailSent(command);
}
public async Task WhenPostingUserRegistration_ItShouldIssueRegisterUserCommand()
{
var registration = NewRegistrationData();
var command = new RegisterUserCommand(
UserId,
registration.ExampleWork,
ValidEmail.Parse(registration.Email),
ValidUsername.Parse(registration.Username),
ValidPassword.Parse(registration.Password),
false);
this.guidCreator.Setup(_ => _.CreateSqlSequential()).Returns(UserId.Value);
this.registerUser.Setup(v => v.HandleAsync(command)).Returns(Task.FromResult(0));
var result = await this.controller.PostRegistrationAsync(registration);
Assert.IsInstanceOfType(result, typeof(OkResult));
this.registerUser.Verify(v => v.HandleAsync(command));
this.guidCreator.Verify(v => v.CreateSqlSequential());
}
public async Task WhenNewEmailListIsSame_AndOrderIsDifferent_ItShouldNotModifyEmailsForBlog()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.target = new UpdateFreeAccessUsersDbStatement(testDatabase, this.requestSnapshot);
await this.CreateDataAsync(testDatabase, true);
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(
CreatorId,
BlogId,
new List <ValidEmail>
{
ValidEmail.Parse("*****@*****.**"),
ValidEmail.Parse("*****@*****.**"),
ValidEmail.Parse("*****@*****.**"),
});
return(ExpectedSideEffects.None);
});
}
public static RequestPasswordResetCommand NewCommand(PasswordResetRequestData data)
{
return(new RequestPasswordResetCommand(
data.Email == null ? null : ValidEmail.Parse(data.Email),
data.Username == null ? null : ValidUsername.Parse(data.Username)));
}
public async Task WhenEmailIsFromFifthweekDomain_ItShouldNotReport()
{
await this.target.HandleAsync(new SendIdentifiedUserInformationCommand(Requester.Unauthenticated, false, ValidEmail.Parse("something" + Constants.FifthweekEmailDomain), Name, Username));
// Test verification handled by strict behaviour.
}
