public void RaiseCanExecuteChanged_InvokeEvent()
{
// Arrange
Task Execute() => Task.CompletedTask;
bool CanExecute() => true;
var errorHandler = new ErrorHandlerTestImplementation((cmd,
exception) =>
{
});
object invokedSender = null;
EventArgs invokedArgs = null;
var command = new AsyncCommand(Execute, CanExecute, errorHandler);
command.CanExecuteChanged += (sender,
args) =>
{
invokedSender = sender;
invokedArgs = args;
};
// Act
command.RaiseCanExecuteChanged();
// Assert
Assert.IsNotNull(invokedSender);
Assert.AreSame(command, invokedSender);
Assert.IsNotNull(invokedArgs);
Assert.AreSame(EventArgs.Empty, invokedArgs);
}
public void AsyncCommand_CanExecuteChanged_Test()
{
//Arrange
bool canCommandExecute = false;
bool didCanExecuteChangeFire = false;
AsyncCommand command = new AsyncCommand(NoParameterTask, commandCanExecute);
command.CanExecuteChanged += handleCanExecuteChanged;
void handleCanExecuteChanged(object?sender, EventArgs e) => didCanExecuteChangeFire = true;
bool commandCanExecute(object?parameter) => canCommandExecute;
Assert.False(command.CanExecute(null));
//Act
canCommandExecute = true;
//Assert
Assert.True(command.CanExecute(null));
Assert.False(didCanExecuteChangeFire);
//Act
command.RaiseCanExecuteChanged();
//Assert
Assert.True(didCanExecuteChangeFire);
Assert.True(command.CanExecute(null));
}
public void AsyncCommand_RaiseCanExecuteChanged_MainThreadCreation_MainThreadExecution_Test()
{
// Arrange
var canCommandExecute = false;
var didCanExecuteChangeFire = false;
var command = new AsyncCommand(NoParameterTask, commandCanExecute);
command.CanExecuteChanged += handleCanExecuteChanged;
bool commandCanExecute(object parameter) => canCommandExecute;
Assert.False(command.CanExecute(null));
// Act
canCommandExecute = true;
// Assert
Assert.True(command.CanExecute(null));
Assert.False(didCanExecuteChangeFire);
// Act
command.RaiseCanExecuteChanged();
// Assert
Assert.True(didCanExecuteChangeFire);
Assert.True(command.CanExecute(null));
void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
}
public void RaisingCanExecuteChangedRaisesCanExecuteChanged()
{
var command = new AsyncCommand <object>(async o => await AsyncMethod(() => { }));
command.MonitorEvents();
command.RaiseCanExecuteChanged();
command.ShouldRaise("CanExecuteChanged");
}
private async Task Login(object parameter)
{
PasswordBox passwordBox = parameter as PasswordBox;
string clearTextPassword = passwordBox.Password;
try
{
//Validate credentials through the authentication service
Employee user = await Task.Factory.StartNew(() => _authenticationService.AuthenticateUser(Username, clearTextPassword));
if (user == null)
{
throw new UnauthorizedAccessException("Access denied. Please provide some valid credentials.");
}
//Get the current principal object
CustomPrincipal customPrincipal = Thread.CurrentPrincipal as CustomPrincipal;
if (customPrincipal == null)
{
throw new ArgumentException("The application's default thread principal must be set to a CustomPrincipal object on startup.");
}
//Authenticate the user
customPrincipal.Identity = new CustomIdentity(user.Username, user.Email, user.Role);
//Update UI
NotifyPropertyChanged("AuthenticatedUser");
NotifyPropertyChanged("IsAuthenticated");
_loginCommand.RaiseCanExecuteChanged();
Username = string.Empty; //reset
passwordBox.Password = string.Empty; //reset
Status = string.Empty;
if (user.Role == "Administrators")
{
Pages.SetPage(Pages.AdminControl);
}
else
{
Pages.SetPage(Pages.EmployeeControl);
}
}
catch (UnauthorizedAccessException)
{
Status = "Login failed! Please provide some valid credentials.";
}
catch (Exception ex)
{
Status = string.Format("ERROR: {0}", ex.Message);
}
finally
{
IsActive = false;
}
}
public async Task AsyncCommand_RaiseCanExecuteChanged_MainThreadCreation_MainThreadExecution_Test()
{
// Arrange
var semaphoreSlim = new SemaphoreSlim(1, 1);
var canCommandExecute = false;
var didCanExecuteChangeFire = false;
var handleCanExecuteChangedTCS = new TaskCompletionSource <object?>();
var command = new AsyncCommand(NoParameterTask, commandCanExecute);
command.CanExecuteChanged += handleCanExecuteChanged;
bool commandCanExecute(object?parameter) => canCommandExecute;
Assert.False(command.CanExecute(null));
// Act
canCommandExecute = true;
// Assert
Assert.IsTrue(command.CanExecute(null));
Assert.False(didCanExecuteChangeFire);
// Act
command.RaiseCanExecuteChanged();
await handleCanExecuteChangedTCS.Task.ConfigureAwait(false);
// Assert
Assert.IsTrue(didCanExecuteChangeFire);
Assert.IsTrue(command.CanExecute(null));
async void handleCanExecuteChanged(object?sender, EventArgs e)
{
await semaphoreSlim.WaitAsync().ConfigureAwait(false);
try
{
command.CanExecuteChanged -= handleCanExecuteChanged;
didCanExecuteChangeFire = true;
handleCanExecuteChangedTCS.SetResult(null);
}
finally
{
semaphoreSlim.Release();
}
}
}
public AsyncCommandViewModel()
{
CounterCommand = new AsyncCommand(async() =>
{
await Task.Delay(2000);
Counter++;
OnCounterCommand.RaiseCanExecuteChanged();
CounterCommand.RaiseCanExecuteChanged();
}, () => Math.Abs(m_counter - m_onClickCounter) < 5);
OnCounterCommand = new AsyncCommand <int>(async num =>
{
await Task.Delay(150);
OnClickCounter = num;
CounterCommand.RaiseCanExecuteChanged();
OnCounterCommand.RaiseCanExecuteChanged();
}, num => Math.Abs(num - OnClickCounter) > 2);
}
public ProfileModel()
{
_dto = new ProfileDto()
{
PhoneNumber = "+79219736635"
};
UpdateCommand = new AsyncCommand()
{
Action = OnUpdate,
CanExecute = CanUpdate
};
CancelCommand = new Command()
{
Action = OnCancel,
CanExecute = (arg) => HasChanges
};
PropertyChanged += (sender, e) =>
{
CancelCommand.RaiseCanExecuteChanged();
UpdateCommand.RaiseCanExecuteChanged();
};
}
private static void InvokeButtonCanExecuteChanged() => AsyncCommand.RaiseCanExecuteChanged();
public void IAsyncCommandT_CanRaiseCanExecuteChanged()
{
IAsyncCommand <string> command = new AsyncCommand <string>(sender => Task.CompletedTask);
command.RaiseCanExecuteChanged();
}
public void IAsyncCommand_CanRaiseCanExecuteChanged()
{
IAsyncCommand command = new AsyncCommand(() => Task.CompletedTask);
command.RaiseCanExecuteChanged();
}
public void RaiseCanExecuteChangedShouldRaiseEvent()
{
// arrange
var raised = false;
var command = new AsyncCommand<object>( p => Task.FromResult( 0 ) );
command.CanExecuteChanged += ( s, e ) => raised = true;
// act
command.RaiseCanExecuteChanged();
// assert
Assert.True( raised );
}
