public void ShouldHaveDriverWaitDoesNotExistFailureWhenDriverWaitIsNull()
{
// Arrange
var id = Guid.NewGuid();
var name = "name";
var image = "image";
var description = "description";
var layout = "layout";
string driverWait = null;
var operators = new List <Guid>()
{
Guid.NewGuid()
};
var filterContent = "{site:123456}";
var version = 1;
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
operators,
filterContent,
version);
// Act
var validationResult = _validator.Validate(command);
var exists =
validationResult.Errors.Any(
a => a.PropertyName.Equals("DriverWait") && a.ErrorMessage.Contains(ValidationFailures.TeamDriverWaitWrongValue));
// Assert
exists.Should().BeTrue();
}
public void ShouldHaveTeamNameMandatoryValidationFailureWhenNameIsWhitespace()
{
// Arrange
var id = Guid.NewGuid();
var name = " ";
var image = "image";
var description = "description";
var layout = "layout";
var driverWait = "driverWait";
var operators = new List <Guid>()
{
Guid.NewGuid()
};
var filterContent = "{site:123456}";
var version = 1;
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
operators,
filterContent,
version);
// Act
var validationResult = _validator.Validate(command);
var exists =
validationResult.Errors.Any(
a => a.PropertyName.Equals("Name") && a.ErrorMessage.Contains(ValidationFailures.TeamNameMandatory));
// Assert
exists.Should().BeTrue();
}
public async Task GivenValidUpdateTeamCommand_ReturnsSuccessCode()
{
var client = await _factory.GetAuthenticatedClientAsync();
var command = new UpdateTeamCommand
{
Id = "197d0438-e04b-453d-b5de-eca05960c6ae",
Name = "Team 1",
Description = "Des11111",
Users = new List <UserModel>
{
new UserModel()
{
UserId = Guid.NewGuid(),
DisplayName = "TestUser1"
}
}
};
var content = IntegrationTestHelper.GetRequestContent(command);
var response = await client.PutAsync($"/api/Team/{command.Id}", content);
response.EnsureSuccessStatusCode();
}
public async Task ShouldUpdateTeamCorrectly()
{
//Arrange
var testUser = new User("test", "test", "test", "test");
var testTeam = new Team(testUser, "test", "test");
var dateUpdated = new DateTime();
var teamsRepository = new Mock <ITeamsRepository>();
teamsRepository.Setup(x => x.Get(It.IsAny <Guid>())).Returns(testTeam);
teamsRepository.Setup(x => x.UpdateAsync(It.IsAny <Team>())).Callback <Team>(x => { testTeam = x; dateUpdated = testTeam.ChangedAt; }).Returns(Task.CompletedTask);
var updateTeamHandler = new UpdateTeamHandler(teamsRepository.Object);
var command = new UpdateTeamCommand(testTeam.Id, "test", "test");
//Act
await updateTeamHandler.HandleAsync(command);
//Assert
teamsRepository.Verify(x => x.Get(It.IsAny <Guid>()), Times.Once);
teamsRepository.Verify(x => x.UpdateAsync(It.IsAny <Team>()), Times.Once);
Assert.That(testTeam.ChangedAt, Is.EqualTo(dateUpdated));
Assert.That(testTeam.Title, Is.EqualTo(command.Title));
Assert.That(testTeam.Description, Is.EqualTo(command.Description));
Assert.That(testTeam.Id, Is.EqualTo(command.TeamId));
}
public async Task Handle_GivenValidId_ShouldUpdatePersistedTeam()
{
var command = new UpdateTeamCommand
{
Id = validId.ToString(),
Name = "Change team name 1.",
Description = "New description.",
Users = new List <UserModel>
{
new UserModel()
{
UserId = Guid.NewGuid(),
DisplayName = "TestUser1"
}
}
};
await _sut.Handle(command, CancellationToken.None);
var entity = _context.Teams.Find(new Guid(command.Id));
entity.ShouldNotBeNull();
entity.Name.ShouldBe(command.Name);
entity.Users.ShouldNotBeNull();
}
public async Task Handle_GivenValidId_LoginUserIsNotLeader_ThrowsException()
{
// Login user is member
var currentUserServiceMock = new Mock <ICurrentUserService>();
currentUserServiceMock.Setup(m => m.UserId)
.Returns(memberId.ToString());
var sut = new UpdateTeamCommandHandler(_context, currentUserServiceMock.Object);
var command = new UpdateTeamCommand
{
Id = validId.ToString(),
Name = "Change team name 1.",
Description = "New description.",
Users = new List <UserModel>
{
new UserModel()
{
UserId = Guid.NewGuid(),
DisplayName = "TestUser1"
}
}
};
await Should.ThrowAsync <NotOwnedException>(() =>
sut.Handle(command, CancellationToken.None));
}
public IActionResult UpdateTeam([FromBody] TeamModel teamModel)
{
var command = new UpdateTeamCommand(teamModel);
CommandDispatcher.Handle(command);
return(Ok());
}
public void ShouldContainNoErrors()
{
// Arrange
var id = Guid.NewGuid();
var name = "name";
var image = "image";
var description = "description";
var layout = "layout";
var driverWait = "No";
var operators = new List <Guid>()
{
Guid.NewGuid()
};
var filterContent = "{site:123456}";
var version = 1;
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
operators,
filterContent,
version);
// Act
var validationResult = _validator.Validate(command);
var exists = validationResult.Errors.Count > 0;
// Assert
exists.Should().BeFalse();
}
public async Task <ResponseApi> Handle(UpdateTeamCommand request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Update Team : { JsonSerializer.Serialize(request)}");
try
{
var validate = request.Validate(_teamRepository);
if (!validate.IsValid)
{
_logger.LogInformation($"ERROR - Update Team : { JsonSerializer.Serialize(validate.Errors.Select(x=> new { Campo = x.PropertyName, Erro = x.ErrorMessage }).ToList() )}");
return(new ResponseApi(false, "Erro ao atualizar o time", validate.Errors.Select(x => new { Campo = x.PropertyName, Erro = x.ErrorMessage }).ToList()));
}
Team team = new Team(request.Id, request.TeamName, request.IsActive);
await _teamRepository.Update(team);
var response = new { Id = team.Id, TeamName = team.TeamName, isActive = team.IsActive };
_logger.LogInformation($"SUCCESS - Update Team: { JsonSerializer.Serialize(response)}");
return(new ResponseApi(true, "Time Atualizado com Sucesso", response));
}
catch (Exception e)
{
_logger.LogInformation($"ERROR - Update Team : { e.InnerException.ToString() }");
return(new ResponseApi(false, "Erro ao atualizar o time", e.InnerException.ToString()));
}
}
public async Task <IActionResult> Update(int id, [FromBody] UpdateTeamCommand command)
{
command.Id = id;
await Mediator.Send(command);
return(NoContent());
}
public async Task HandleShouldFailWhenRecordWithSameNameAlreadyExist()
{
// Arrange
var id = Guid.NewGuid();
var name = "name";
var image = "image";
var description = "description";
var layout = "layout";
var driverWait = "Yes";
var operators = new List <Guid>()
{
Guid.NewGuid()
};
var filterContent = "{site:123456}";
var version = 1;
var team = new Team(TeamId.With(id), new Name(name));
team.SetVersion(version);
var teamWriteRepositoryMock = new Mock <ITeamWriteRepository>();
teamWriteRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <Team>())).Throws <UniqueKeyException>();
var teamWriteRepository = teamWriteRepositoryMock.Object;
var teamReadRepositoryMock = new Mock <ITeamReadRepository>();
teamReadRepositoryMock.Setup(x => x.GetAsync(id)).Returns(Task.FromResult(team));
var teamReadRepository = teamReadRepositoryMock.Object;
var versionProviderMock = new Mock <IVersionProvider>();
versionProviderMock.Setup(x => x.Generate()).Returns(version);
var versionProvider = versionProviderMock.Object;
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
operators,
filterContent,
version);
var handler = new UpdateTeamCommandHandler(teamWriteRepository, teamReadRepository, versionProvider);
// Act
var result = await handler.Handle(command, CancellationToken.None);
// Assert
result.IsFailure.Should().BeTrue();
result.Failures.Should().OnlyContain(x => x.Code == HandlerFaultCode.Conflict.Name &&
x.Message == HandlerFailures.ConflictTeam &&
x.Target == "name");
}
public async Task <IActionResult> UpdateTeam([FromBody] UpdateTeamCommand command)
{
if (command is null)
{
return(BadRequest());
}
return(Json(await _mediator.Send(command)));
}
public async Task Handle_GivenNewMember_ShouldUpdatePublicChannels()
{
// Arrange
var command = new UpdateTeamCommand
{
Id = validId.ToString(),
Name = "Change team name 1.",
Description = "New description.",
Users = new List <UserModel>
{
// old members
new UserModel
{
UserId = leaderId,
DisplayName = "User1",
TeamRole = "Leader"
},
new UserModel
{
UserId = memberId,
DisplayName = "User2",
TeamRole = "Member"
},
new UserModel
{
UserId = userId3,
DisplayName = "User3",
TeamRole = "Member"
},
new UserModel
{
UserId = userId4,
DisplayName = "User4",
TeamRole = "Member"
},
// new member
new UserModel
{
UserId = new Guid(),
DisplayName = "new-member",
TeamRole = "Member"
},
}
};
await _sut.Handle(command, CancellationToken.None);
var afterUpdateMembers = (await _context.Teams.FindAsync(validId)).Users;
var lstPublicChannels = _context.Conversations
.Where(con => con.isPublic && con.TeamId == validId.ToString());
foreach (var publicChannel in lstPublicChannels)
{
publicChannel.Members.ShouldBe(afterUpdateMembers);
}
}
public async Task HandleShouldReturnFailWhenNotFound()
{
// Arrange
var id = Guid.NewGuid();
var name = "name";
var image = "image";
var description = "description";
var layout = "layout";
var driverWait = "Yes";
var operators = new List <Guid>()
{
Guid.NewGuid()
};
var filterContent = "{site:123456}";
var version = 1;
var teamWriteRepositoryMock = new Mock <ITeamWriteRepository>();
teamWriteRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <Team>())).Returns(Task.CompletedTask);
var teamWriteRepository = teamWriteRepositoryMock.Object;
var teamReadRepositoryMock = new Mock <ITeamReadRepository>();
teamReadRepositoryMock.Setup(x => x.GetAsync(id)).Throws <EntityNotFoundDbException>();
var teamReadRepository = teamReadRepositoryMock.Object;
var versionProviderMock = new Mock <IVersionProvider>();
versionProviderMock.Setup(x => x.Generate()).Returns(version);
var versionProvider = versionProviderMock.Object;
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
operators,
filterContent,
version);
var handler = new UpdateTeamCommandHandler(teamWriteRepository, teamReadRepository, versionProvider);
// Act
var result = await handler.Handle(command, CancellationToken.None);
// Assert
result.IsFailure.Should().BeTrue();
result.Failures.Should().OnlyContain(x => x.Code == HandlerFaultCode.NotFound.Name &&
x.Message == HandlerFailures.TeamNotFound &&
x.Target == "id");
}
public async Task HandleShouldReturnOk()
{
// Arrange
var id = Guid.NewGuid();
var name = "name";
var image = "image";
var description = "description";
var layout = "layout";
var driverWait = "Yes";
var operators = new List <Guid>()
{
Guid.NewGuid()
};
var filterContent = "{site:123456}";
var version = 1;
var team = new Team(TeamId.With(id), new Name(name));
team.SetVersion(version);
var teamWriteRepositoryMock = new Mock <ITeamWriteRepository>();
teamWriteRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <Team>())).Returns(Task.CompletedTask);
var teamWriteRepository = teamWriteRepositoryMock.Object;
var teamReadRepositoryMock = new Mock <ITeamReadRepository>();
teamReadRepositoryMock.Setup(x => x.GetAsync(id)).Returns(Task.FromResult(team));
var teamReadRepository = teamReadRepositoryMock.Object;
var versionProviderMock = new Mock <IVersionProvider>();
versionProviderMock.Setup(x => x.Generate()).Returns(version);
var versionProvider = versionProviderMock.Object;
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
operators,
filterContent,
version);
var handler = new UpdateTeamCommandHandler(teamWriteRepository, teamReadRepository, versionProvider);
// Act
var result = await handler.Handle(command, CancellationToken.None);
// Assert
result.IsFailure.Should().BeFalse();
result.Should().BeOfType(typeof(Result));
}
public async Task <ActionResult> UpdateTeam(string id, UpdateTeamCommand command)
{
if (!id.Equals(command.Id))
{
return(BadRequest());
}
await Mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> UpdateTeamAsync(
[FromRoute] Guid teamId,
[FromBody] UpdateTeamCommand updateTeamCommand,
CancellationToken cancellationToken)
{
updateTeamCommand.TeamId = teamId;
await _squadHandler.UpdateTeamAsync(updateTeamCommand, cancellationToken);
return(Ok());
}
public void MapUpdateTeamRequestShouldSucceed()
{
// Arrange
var ifMatch = "123456";
var version = 123456;
var apiVersion = "1.0";
var id = Guid.NewGuid();
var name = "Test";
var image = "update";
var description = "updatedeDescription";
var driverWait = "No";
var layout = Guid.NewGuid().ToString();
var filterContent = "{site:123456}";
var members = new List <Guid>();
// Act
var request = new UpdateTeamRequest(new UpdateTeamFromHeader()
{
IfMatch = ifMatch
},
new UpdateTeamFromQuery()
{
ApiVersion = apiVersion
},
new UpdateTeamFromRoute()
{
Id = id.ToString()
},
new UpdateTeamFromBody()
{
Name = name,
Image = image,
Description = description,
DriverWait = driverWait,
Layout = layout,
Members = members,
FilterContent = filterContent
});
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
members,
filterContent,
version);
var mappedCommand = _cqsMapper.Map(request);
// Assert
command.Should().BeEquivalentTo(mappedCommand);
}
public async Task <IActionResult> UpdateTeam([FromRoute] string teamId, [FromBody] UpdateTeamRequest request,
CancellationToken cancellationToken)
{
var command = new UpdateTeamCommand
(
ObjectId.Parse(teamId),
request.Name
);
await _commandDispatcher.DispatchAsync(command, cancellationToken);
return(StatusCode(204));
}
public void Handle_GivenInvalidId_ThrowsException()
{
var command = new UpdateTeamCommand
{
Id = "99",
Name = "This item doesn't exist.",
Description = "This item doesn't exist."
};
Should.ThrowAsync <NotFoundException>(() =>
_sut.Handle(command, CancellationToken.None));
}
public async Task Should_ThrowException_When_PassInvalidUserId()
{
// Arrange
var team = new Team()
{
TeamName = "Test Team",
CompanyId = 1,
CreatedAt = DateTime.UtcNow,
CreatedBy = -1
};
team.TeamMembers.Add(new TeamMember()
{
IsApprover = true,
IsMember = true,
UserId = 1
});
_fixture.Context.Teams.Attach(team);
await _fixture.Context.SaveChangesAsync();
IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context);
IRepository <Team> repository = new Repository <Team>(_fixture.Context);
IRepository <User> userRepository = new Repository <User>(_fixture.Context);
var handler = new UpdateTeamHandler(unitOfWork, repository, userRepository, _logger, _mapper);
var request = new UpdateTeamCommand(companyId: 1,
userId: 1,
teamId: 1,
"Test Team - 1",
members: new List <int>()
{
1, -22
},
approvers: new List <int>()
{
1
});
// Act
var tcs = new CancellationToken();
// Assert
var exception = await Assert.ThrowsAsync <VacationTrackingException>(async() =>
{
var result = await handler.Handle(request, tcs);
});
Assert.Equal(ExceptionMessages.InvalidUserId, exception.Message);
Assert.Equal(400, exception.Code);
}
public void IsValid_ShouldBeTrue_WhenNameIsNotNull()
{
var command = new UpdateTeamCommand
{
Id = validId.ToString(),
Name = "Not Null < 200 byte"
};
var validator = new UpdateTeamCommandValidator();
var result = validator.Validate(command);
result.IsValid.ShouldBe(true);
}
public void IsValid_ShouldBeFalse_WhenNameIsNull()
{
var command = new UpdateTeamCommand
{
Id = validId.ToString(),
Name = null
};
var validator = new UpdateTeamCommandValidator();
var result = validator.Validate(command);
result.IsValid.ShouldBe(false);
}
public async Task Should_UpdateTeam_When_PassValidParameters()
{
// Arrange
var team = new Team()
{
TeamName = "Test Team",
CompanyId = 1,
CreatedAt = DateTime.UtcNow,
CreatedBy = -1
};
team.TeamMembers.Add(new TeamMember()
{
IsApprover = true,
IsMember = true,
UserId = 1
});
_fixture.Context.Teams.Attach(team);
await _fixture.Context.SaveChangesAsync();
IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context);
IRepository <Team> repository = new Repository <Team>(_fixture.Context);
IRepository <User> userRepository = new Repository <User>(_fixture.Context);
var handler = new UpdateTeamHandler(unitOfWork, repository, userRepository, _logger, _mapper);
var request = new UpdateTeamCommand(companyId: 1,
userId: 1,
teamId: 1,
"Test Team - 1",
members: new List <int>()
{
1, 2
},
approvers: new List <int>()
{
1
});
// Act
var tcs = new CancellationToken();
var result = await handler.Handle(request, tcs);
// Assert
Assert.Equal("Test Team - 1", result.TeamName);
Assert.Equal(2, result.TeamMembers.Count(x => x.IsMember));
Assert.Equal(1, result.TeamMembers.Count(x => x.IsApprover));
Assert.Equal(1, result.ModifiedBy);
}
public async Task Handle_GivenValidId_ShouldUpdatePersistedTeam_User2IsDeleteOfTeam()
{
var command = new UpdateTeamCommand
{
Id = validId.ToString(),
Name = "Change team name 1.",
Description = "New description.",
Users = new List <UserModel>
{
new UserModel
{
UserId = leaderId,
DisplayName = "User1",
TeamRole = "Leader"
},
new UserModel
{
UserId = userId3,
DisplayName = "User3",
TeamRole = "Member"
}
}
};
var channelsBeforeUpdateTeam = _context.Conversations.Where(channel => channel.TeamId == validId.ToString()).ToList();
foreach (var channel in channelsBeforeUpdateTeam)
{
channel.Members.Any(member => member.UserOid.Equals(memberId.ToString())).ShouldBeTrue();
}
await _sut.Handle(command, CancellationToken.None);
var entity = _context.Teams.Find(new Guid(command.Id));
var channelsAfterUpdateTeam = _context.Conversations.Where(channel => channel.TeamId == validId.ToString()).ToList();
entity.ShouldNotBeNull();
entity.Name.ShouldBe(command.Name);
entity.Users.ShouldNotBeNull();
foreach (var channel in channelsAfterUpdateTeam)
{
channel.Members.Any(member => member.UserOid.Equals(memberId.ToString())).ShouldBeFalse();
}
}
public UpdateTeamCommand Map(UpdateTeamRequest request)
{
var version = ToVersion(request.HeaderIfMatch);
var id = new Guid(request.RouteId);
var command = new UpdateTeamCommand(id,
request.Name,
request.Image,
request.Description,
request.DriverWait,
request.Layout,
request.Members,
request.FilterContent,
version);
return(command);
}
public async Task UpdateTeamAsync(
UpdateTeamCommand updateTeamCommand,
CancellationToken cancellationToken)
{
var team = await _squadRepository.GetAsync(updateTeamCommand.SquadId, cancellationToken);
var isUpdated = team.UpdateTeamName(updateTeamCommand.TeamId, updateTeamCommand.Name);
isUpdated = team.UpdateTeamOwner(updateTeamCommand.TeamId, updateTeamCommand.TeamOwnerId);
isUpdated = team.UpdateTeamPoints(updateTeamCommand.TeamId, updateTeamCommand.Points);
isUpdated = team.UpdateTeamDescription(updateTeamCommand.TeamId, updateTeamCommand.Description);
if (isUpdated)
{
_squadRepository.Update(team);
await _squadRepository.SaveAsync(cancellationToken);
}
}
public void CtorShouldFillProperties()
{
// Arrange
var id = Guid.NewGuid();
var name = "name";
var image = "image";
var description = "description";
var layout = "layout";
var driverWait = "driverWait";
var operators = new List <Guid>()
{
Guid.NewGuid()
};
var filterContent = "{site:123456}";
var version = 1;
// Act
var result = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
operators,
filterContent,
version);
// Assert
result.Id.Should().Be(id);
result.Name.Should().Be(name);
result.Image.Should().Be(image);
result.Description.Should().Be(description);
result.Layout.Should().Be(layout);
result.DriverWait.Should().Be(driverWait);
result.Version.Should().Be(version);
}
public async Task UpdateTeamCommand_Can_Update_Team()
{
using (var dbContext = GetDbContext("UpdateTeamCommand_Can_Update_Team"))
{
var fakeRepo = new TeamRepository(dbContext);
await fakeRepo.AddAsync(new Domain.Entities.Team
{
Name = "TeamName",
Longitude = 8.11,
Latitude = 9.43,
});
}
using (var dbContext = GetDbContext("UpdateTeamCommand_Can_Update_Team"))
{
var fakeRepo = new TeamRepository(dbContext);
var fakeLogger = new Mock <ILogger <UpdateTeamCommandHandler> >();
var handler = new UpdateTeamCommandHandler(fakeRepo, GetMapper(), fakeLogger.Object);
var command = new UpdateTeamCommand
{
Id = 1,
Name = "NewTeamName",
Longitude = 2.11,
Latitude = 6.43,
};
var result = await handler.Handle(command, default);
Assert.False(result.Notifications.HasErrors());
Assert.Equal(command.Name, result.TeamLookupModel.Name);
Assert.Equal(command.Longitude, result.TeamLookupModel.Longitude);
Assert.Equal(command.Latitude, result.TeamLookupModel.Latitude);
}
}
public FIFATeamDTO Update(UpdateTeamCommand request)
{
throw new System.NotImplementedException();
}
