public static ConfirmPasswordResetCommand NewCommand(PasswordResetConfirmationData data)
{
return(new ConfirmPasswordResetCommand(
data.UserId,
data.Token,
ValidPassword.Parse(data.NewPassword)));
}
public async Task CallsTheUserAccessManagerWhenThePasswordIsValid()
{
ViewModel.Password.OnNext(ValidPassword.ToString());
ViewModel.Done.Execute();
TestScheduler.Start();
await UserAccessManager.Received().RefreshToken(Arg.Is(ValidPassword));
}
public void IsSuccessfullyEmmited()
{
var passwordObserver = Observe(ViewModel.Password.Select(Password.From));
ViewModel.Password.OnNext(ValidPassword.ToString());
TestScheduler.Start();
passwordObserver.LastEmittedValue().Should().Be(ValidPassword);
}
public void ReturnsTrueIfThePasswordIsValid()
{
var nextIsEnabledObserver = Observe(ViewModel.NextIsEnabled);
ViewModel.Password.OnNext(ValidPassword.ToString());
TestScheduler.Start();
nextIsEnabledObserver.LastEmittedValue().Should().BeTrue();
}
public async Task DoesNotNavigateWhenTheLoginFails()
{
ViewModel.Password.OnNext(ValidPassword.ToString());
UserAccessManager.RefreshToken(Arg.Any <Password>())
.Returns(Observable.Throw <ITogglDataSource>(new Exception()));
ViewModel.Done.Execute();
TestScheduler.Start();
await NavigationService.DidNotReceive().Navigate <MainViewModel>();
}
public async Task NavigatesToTheMainViewModelModelWhenTheTokenRefreshSucceeds()
{
ViewModel.Password.OnNext(ValidPassword.ToString());
UserAccessManager.RefreshToken(Arg.Any <Password>())
.Returns(Observable.Return(Substitute.For <ITogglDataSource>()));
ViewModel.Done.Execute();
TestScheduler.Start();
await NavigationService.Received().ForkNavigate <MainTabBarViewModel, MainViewModel>();
}
public void ReturnsFalseWheThePasswordIsValidButTheViewIsLoading()
{
var never = Observable.Never <Unit>();
UserAccessManager.RefreshToken(Arg.Any <Password>()).Returns(never);
ViewModel.Password.OnNext(ValidPassword.ToString());
var nextIsEnabledObserver = Observe(ViewModel.NextIsEnabled);
ViewModel.Done.Execute();
TestScheduler.Start();
nextIsEnabledObserver.LastEmittedValue().Should().BeFalse();
}
public void StopsTheViewModelLoadStateWhenItErrors()
{
ViewModel.Password.OnNext(ValidPassword.ToString());
UserAccessManager.RefreshToken(Arg.Any <Password>())
.Returns(Observable.Throw <ITogglDataSource>(new Exception()));
var isLoadingObserver = Observe(ViewModel.Done.Executing);
ViewModel.Done.Execute();
TestScheduler.Start();
var messages = isLoadingObserver.Messages.ToList();
isLoadingObserver.LastEmittedValue().Should().BeFalse();
}
public async Task SetsThePasswordFieldWhenValidCredentialsAreProvided()
{
arrangeCallToPasswordManagerWithValidCredentials();
var observer = TestScheduler.CreateObserver <string>();
ViewModel.Password.Subscribe(observer);
await ViewModel.StartPasswordManager();
TestScheduler.Start();
observer.Messages.AssertEqual(
ReactiveTest.OnNext(1, Password.Empty.ToString()),
ReactiveTest.OnNext(2, ValidPassword.ToString())
);
}
public async Task StopsTheViewModelLoadStateWhenItCompletes()
{
await ViewModel.Initialize();
ViewModel.Password.OnNext(ValidPassword.ToString());
var isLoadingObserver = Observe(ViewModel.Done.Executing);
UserAccessManager.RefreshToken(Arg.Any <Password>())
.Returns(Observable.Return(Substitute.For <ITogglDataSource>()));
ViewModel.Done.Execute();
TestScheduler.Start();
isLoadingObserver.LastEmittedValue().Should().BeFalse();
}
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 <UpdateAccountSettingsResult> ExecuteAsync(
UserId userId,
ValidUsername newUsername,
ValidEmail newEmail,
ValidPassword newPassword,
FileId newProfileImageFileId,
string newSecurityStamp)
{
userId.AssertNotNull("userId");
newUsername.AssertNotNull("newUsername");
newEmail.AssertNotNull("newEmail");
string passwordHash = null;
if (newPassword != null)
{
passwordHash = this.userManager.PasswordHasher.HashPassword(newPassword.Value);
}
var query = new StringBuilder();
query.AppendLine(@"DECLARE @emailConfirmed bit");
query.Append(@"
UPDATE dbo.AspNetUsers
SET
Email = @Email,
UserName = @Username,
ProfileImageFileId = @ProfileImageFileId,
SecurityStamp = @SecurityStamp,
@emailConfirmed =
(
CASE
WHEN
((EmailConfirmed = 0) OR (Email != @Email))
THEN
0
ELSE
1
END
),
EmailConfirmed = @emailConfirmed");
if (passwordHash != null)
{
query.Append(@", PasswordHash=@PasswordHash");
}
query.AppendLine().Append(@"WHERE Id=@UserId").AppendLine();
query.Append(@"select @emailConfirmed");
bool emailConfirmed;
using (var transaction = TransactionScopeBuilder.CreateAsync())
{
using (var connection = this.connectionFactory.CreateConnection())
{
emailConfirmed = await connection.ExecuteScalarAsync <bool>(
query.ToString(),
new
{
UserId = userId.Value,
Username = newUsername.Value,
Email = newEmail.Value,
PasswordHash = passwordHash,
SecurityStamp = newSecurityStamp,
ProfileImageFileId = newProfileImageFileId == null ? (Guid?)null : newProfileImageFileId.Value
});
}
await this.requestSnapshot.ExecuteAsync(userId, SnapshotType.Subscriber);
transaction.Complete();
}
return(new UpdateAccountSettingsResult(emailConfirmed));
}
