public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser()
{
var options = this.CreateNewContextOptions();
const string userId = "12345";
const string firstName = "changed";
var message = new UpdateUser {
User = new ApplicationUser {
Id = userId,
FirstName = firstName
}
};
using (var context = new AllReadyContext(options)) {
context.Users.Add(new ApplicationUser {
Id = userId,
FirstName = "notChanged"
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new UpdateUserHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var user = context.Users.FirstOrDefault(u => u.Id == userId);
Assert.NotNull(user);
Assert.Equal(user.FirstName, firstName);
}
}
public async void SouldReturnSuccess_WhenCommandUpdateUserIsInvalid()
{
// arrange
var(repo, context) = GetRepository();
var entity = new UserEntity {
Email = "*****@*****.**", Name = "test1", Password = "******"
};
_ = await repo.Save(entity);
context.Entry(entity).State = EntityState.Detached;
var comando = new UpdateUserCommand {
Id = 1, Email = "*****@*****.**", Nome = "test2"
};
var handler = new UpdateUserHandler(repo);
// act
_ = await handler.Handle(comando, CancellationToken.None);
// assert
//var result = await repo.GetById(comando.Id);
var result = context.UserEntityDb.Find(comando.Id);
Assert.Equal(comando.Email, result.Email);
}
public async Task ShouldUpdateUser()
{
// Arrange
using var scope = Factory.Services.CreateScope();
var updateUserModel = new UpdateUserModel
{
FirstName = "updated first name",
LastName = "updated last name",
};
var sut = new UpdateUserHandler(unitOfWork, mediator, mapper, currentUserServiceMock.Object);
// Act
GetPrivateUserModel sutResult = await sut.Handle(new UpdateUserCommand(updateUserModel), new CancellationToken(false));
// Assert
Assert.NotNull(sutResult);
var updatedUser = await unitOfWork.Users.GetEntityAsync(sutResult.Id);
Assert.NotNull(updatedUser);
Assert.False(updatedUser.Deleted);
Assert.Equal(updatedUser.UserName, user.UserName);
Assert.Equal(updatedUser.FirstName, updateUserModel.FirstName);
Assert.Equal(updatedUser.LastName, updateUserModel.LastName);
}
public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser()
{
var options = this.CreateNewContextOptions();
const string userId = "12345";
const string firstName = "changed";
var message = new UpdateUser { User = new ApplicationUser {
Id = userId,
FirstName = firstName
} };
using (var context = new AllReadyContext(options)) {
context.Users.Add(new ApplicationUser {
Id = userId,
FirstName = "notChanged"
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new UpdateUserHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var user = context.Users.FirstOrDefault(u => u.Id == userId);
Assert.NotNull(user);
Assert.Equal(user.FirstName, firstName);
}
}
public async Task ShouldUpdateUserAccountCorrectly()
{
//Arrange
User user = new User("test", "test", "test", "test");
var usersRepository = new Mock <IUsersRepository>();
var dateUpdated = new DateTime();
usersRepository.Setup(x => x.Get(It.IsAny <Guid>()))
.Returns(user);
usersRepository.Setup(x => x.UpdateAsync(It.IsAny <User>()))
.Callback <User>(x =>
{
user = x;
dateUpdated = user.ChangedAt;
})
.Returns(Task.CompletedTask);
var updateUserHandler = new UpdateUserHandler(usersRepository.Object);
var command = new UpdateUserCommand(user.Id, "test2", "test2", "test2", "test2", "test2");
//Act
await updateUserHandler.HandleAsync(command);
//Assert
usersRepository.Verify(x => x.Get(It.IsAny <Guid>()), Times.Once);
usersRepository.Verify(x => x.UpdateAsync(It.IsAny <User>()), Times.Once);
Assert.That(user.ChangedAt, Is.EqualTo(dateUpdated));
Assert.That(user.Username, Is.EqualTo(command.Username));
Assert.That(user.Email, Is.EqualTo(command.Email));
Assert.That(user.Forename, Is.EqualTo(command.Forename));
Assert.That(user.Surname, Is.EqualTo(command.Surname));
Assert.That(user.City, Is.EqualTo(command.City));
}
public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser()
{
var message = new UpdateUser { User = new ApplicationUser() };
var dataAccess = new Mock<IAllReadyDataAccess>();
var sut = new UpdateUserHandler(dataAccess.Object);
await sut.Handle(message);
dataAccess.Verify(x => x.UpdateUser(message.User), Times.Once);
}
public UpdateUserHandlerTests()
{
_userRepositoryMock = new Mock <IUserRepository>();
_schoolingRepositoryMock = new Mock <ISchoolingRepository>();
_updateUserHandler = new UpdateUserHandler(
_userRepositoryMock.Object,
_schoolingRepositoryMock.Object);
}
public async Task Update_user_handler_scenarios(Scenarios scenario)
{
var(request, expectedResponse, dependencies) = Fixture.SetupForScenario(scenario);
var(mediator, userStoreFactory, cdnCachePurge) = dependencies;
var sut = new UpdateUserHandler(mediator, userStoreFactory, cdnCachePurge);
var response = await sut.Handle(request, default);
Assert.IsTrue(response.IsEquivalentTo(expectedResponse));
}
public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser()
{
var message = new UpdateUser {
User = new ApplicationUser()
};
var dataAccess = new Mock <IAllReadyDataAccess>();
var sut = new UpdateUserHandler(dataAccess.Object);
await sut.Handle(message);
dataAccess.Verify(x => x.UpdateUser(message.User), Times.Once);
}
public void ThrowsExceptionWhenUserDoesntExist()
{
var mock = Mock;
mock.Setup(r => r.Get(It.IsAny <Guid>())).Returns <User>(null);
var handler = new UpdateUserHandler(mock.Object);
Action a = () => handler.Handle(Request, new System.Threading.CancellationToken());
a.Should().Throw <EntityNotFoundException>();
}
public void ThrowsExceptionWhenUserIsInactive()
{
var mock = Mock;
mock.Setup(r => r.Get(It.IsAny <Guid>())).Returns(new User {
IsActive = false
});
var handler = new UpdateUserHandler(mock.Object);
Action a = () => handler.Handle(Request, new System.Threading.CancellationToken());
a.Should().Throw <EntityInactiveException>();
}
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateFromUserType(userType);
UserManager <ApplicationUser> userManager = A.Fake <UserManager <ApplicationUser> >();
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser(Guid.NewGuid().ToString(), "TestFirstName", "TestLastName");
// Act
Func <Task> action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <SecurityException>(action);
}
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateFromUserType(userType);
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser(Guid.NewGuid().ToString(), "TestFirstName", "TestLastName");
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task Return_failed_result_when_validation_fails()
{
// Arrange
var validator = Substitute.For <IValidateRequest <UpdateUser> >();
validator
.IsValidAsync(Arg.Any <UpdateUser>())
.Returns(Task.FromResult(false));
var sut = new UpdateUserHandler(validator, _dbContext);
// Act
var result = await sut.Handle(new UpdateUser("a-sub", new UserRequest()), CancellationToken.None);
// Assert
result.IsFailure.ShouldBeTrue();
}
public async Task HandleAsync_WithUnknownUserId_ThrowsArgumentException()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns((ApplicationUser)null);
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "TestFirstName", "TestLastName");
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<ArgumentException>(action);
}
public async Task HandleAsync_WithNonInternalAdminRole_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.DenyRole(Roles.InternalAdmin)
.Build();
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
var handler = new UpdateUserHandler(authorization, userManager);
// Act
Func<Task> action = async () => await handler.HandleAsync(A.Dummy<UpdateUser>());
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithUnknownUserId_ThrowsArgumentException()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UserManager <ApplicationUser> userManager = A.Fake <UserManager <ApplicationUser> >();
A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns((ApplicationUser)null);
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "TestFirstName", "TestLastName");
// Act
Func <Task> action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <ArgumentException>(action);
}
public async Task HandleAsync_WithNonInternalAdminRole_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.DenyRole(Roles.InternalAdmin)
.Build();
UserManager <ApplicationUser> userManager = A.Fake <UserManager <ApplicationUser> >();
var handler = new UpdateUserHandler(authorization, userManager);
// Act
Func <Task> action = async() => await handler.HandleAsync(A.Dummy <UpdateUser>());
// Assert
await Assert.ThrowsAsync <SecurityException>(action);
}
public virtual void Setup()
{
DataContext = DataContextHelper.GetInMemoryDataContext();
CancellationToken = new CancellationToken();
Handler = new UpdateUserHandler(DataContext);
var user1 = new User {
Username = Guid.NewGuid().ToString()
};
var user2 = new User {
Username = Guid.NewGuid().ToString()
};
DataContext.Users.AddRange(user1, user2);
DataContext.SaveChanges();
ExistingUser = user1;
AnotherExistingUser = user2;
}
public void HandlerUpdatesUser()
{
var mock = Mock;
var user = User;
user.IsActive = true;
var request = Request;
mock.Setup(r => r.Get(It.IsAny <Guid>())).Returns(user);
var handler = new UpdateUserHandler(mock.Object);
handler.Handle(Request, new System.Threading.CancellationToken());
user.FirstName.Should().BeSameAs(request.FirstName);
user.LastName.Should().BeSameAs(request.LastName);
user.Email.Should().BeSameAs(request.Email);
user.Username.Should().BeSameAs(request.Username);
mock.Verify(r => r.Get(It.IsAny <Guid>()), Times.Once);
}
public void UpdatesUserInRepository_RaisesIntegrationEvent()
{
var user = new Domain.User(Id, "A B", "*****@*****.**", false);
var repository = new Mock <IUserRepository>(MockBehavior.Strict);
repository.Setup(r => r.GetAsync(user.Id)).Returns(Task.FromResult(user)).Verifiable();
repository.Setup(r => r.UpdateAsync(user)).Returns(Task.CompletedTask).Verifiable();
repository.Setup(r => r.SaveChanges()).Returns(Task.CompletedTask).Verifiable();
var busPublisher = new Mock <IBusPublisher>(MockBehavior.Strict);
busPublisher.Setup(p => p.Publish <IUserUpdated>(It.Is <IUserUpdated>(e => ValidateEquality(e)))).Returns(Task.CompletedTask).Verifiable();
var handler = new UpdateUserHandler(repository.Object, busPublisher.Object);
var result = handler.HandleAsync(Cmd, new Mock <ICorrelationContext>().Object).GetAwaiter().GetResult();
Assert.IsTrue(result.Successful);
repository.Verify();
busPublisher.Verify();
ValidateEquality(user);
}
public HttpResponseMessage Update(User user, string ticket) //done, should i check if only id recieved?
{
var securityProvider = new SecurityProvider(_connectionString);
var sessionInfo = securityProvider.GetSessionInfo(ticket);
if (sessionInfo == null)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
var updateRequest = new UpdateUserRequest
{
UserToUpdate = user,
UserOrigin = sessionInfo.User,
};
var handler = new UpdateUserHandler(_connectionString);
var response = handler.Handle(updateRequest);
var statusCode = ResolveStatusCode(response);
return(Request.CreateResponse(statusCode, response));
}
public async Task HandleAsync_HappyPath_UpdatedUserInformation()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
ApplicationUser user = new ApplicationUser();
UserManager <ApplicationUser> userManager = A.Fake <UserManager <ApplicationUser> >();
A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns(user);
A.CallTo(() => userManager.UpdateAsync(user)).Returns(IdentityResult.Success);
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "Test", "Test");
// Act
var result = await handler.HandleAsync(request);
// Assert
Assert.Equal(user.FirstName, "Test");
Assert.Equal(user.Surname, "Test");
A.CallTo(() => userManager.UpdateAsync(user)).MustHaveHappened();
}
public async Task HandleAsync_HappyPath_UpdatedUserInformation()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
ApplicationUser user = new ApplicationUser();
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns(user);
A.CallTo(() => userManager.UpdateAsync(user)).Returns(IdentityResult.Success);
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "Test", "Test");
// Act
var result = await handler.HandleAsync(request);
// Assert
Assert.Equal(user.FirstName, "Test");
Assert.Equal(user.Surname, "Test");
A.CallTo(() => userManager.UpdateAsync(user)).MustHaveHappened();
}
