public void MapDeleteTeamShouldSucceed()
{
// Arrange
var id = Guid.NewGuid();
var apiVersion = "1.0";
var version = 34567;
var ifMatch = "34567";
// Act
var request = new DeleteTeamRequest(new DeleteTeamFromRoute()
{
Id = id.ToString()
},
new DeleteTeamFromQuery()
{
ApiVersion = apiVersion
},
new DeleteTeamFromHeader()
{
IfMatch = ifMatch
});
var command = new DeleteTeamCommand(id, version);
var mappedCommand = _cqsMapper.Map(request);
// Assert
command.Should().BeEquivalentTo(mappedCommand);
}
public async Task DeleteTeamCommand_Can_Delete_Team()
{
using (var dbContext = GetDbContext("DeleteTeamCommand_Can_Delete_Team"))
{
var fakeRepo = new TeamRepository(dbContext);
await fakeRepo.AddAsync(new Domain.Entities.Team
{
Name = "TestTeamName"
});
}
using (var dbContext = GetDbContext("DeleteTeamCommand_Can_Delete_Team"))
{
var fakeRepo = new TeamRepository(dbContext);
var fakeLogger = new Mock <ILogger <DeleteTeamCommandHandler> >();
var handler = new DeleteTeamCommandHandler(fakeRepo, GetMapper(), fakeLogger.Object);
var command = new DeleteTeamCommand
{
Id = 1,
};
var result = await handler.Handle(command, default);
Assert.False(result.Notifications.HasErrors());
Assert.Equal(command.Id, result.TeamDeleteModel.Id);
Assert.Equal(Domain.Enumerations.EnumBag.DataState.Inactive, result.TeamDeleteModel.DataState);
}
}
public async Task <CommandResponse> ExecuteAsync(DeleteTeamCommand command)
{
// delete team
bool isDeleted = false;
string message = "Team deleated";
try
{
isDeleted = await unitOfWork.GetRepository <Team, TeamRepository>().DeleteAsync(command.TeamId);
if (!isDeleted)
{
message = "Could not delete team";
}
await unitOfWork.SaveAsync();
}
catch (System.Exception e)
{
isDeleted = false;
message = Common.Algorithms.GetFullText(e);
}
// result
return(new CommandResponse
{
IsSucessed = isDeleted,
Message = message
});
}
public DeleteTeamCommand Map(DeleteTeamRequest request)
{
var id = new Guid(request.RouteId);
var version = ToVersion(request.HeaderIfMatch);
var command = new DeleteTeamCommand(id, version);
return(command);
}
public async Task Handle_GivenInvalidId_ThrowsNotFoundException()
{
var invalidId = Guid.NewGuid();
var command = new DeleteTeamCommand {
Id = invalidId.ToString()
};
await Assert.ThrowsAsync <NotFoundException>(() => _sut.Handle(command, CancellationToken.None));
}
public async Task <IActionResult> DeleteTeam(DeleteTeamCommand command)
{
if (command is null)
{
return(BadRequest());
}
await _mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> DeleteTeam([FromRoute] string teamId, CancellationToken cancellationToken)
{
var command = new DeleteTeamCommand
(
ObjectId.Parse(teamId)
);
await _commandDispatcher.DispatchAsync(command, cancellationToken);
return(StatusCode(204));
}
public void ShouldContainNoErrors()
{
// Arrange
var command = new DeleteTeamCommand(id: Guid.NewGuid(), version: 0);
// Act
var validationResult = _validator.Validate(command);
var exists = validationResult.Errors.Count > 0;
// Assert
exists.Should().BeFalse();
}
public void Delete(DeleteTeamCommand request)
{
for (int i = 0; i < FIFATeamDB.Items.Count; i++)
{
var team = FIFATeamDB.Items[i];
if (team.TournamentId == request.TournamentId && team.PlayerId == request.PlayerId)
{
FIFATeamDB.Items.RemoveAt(i);
break;
}
}
}
public void CtorShouldFillProperties()
{
// Arrange
var id = Guid.NewGuid();
var version = 1;
// Act
var result = new DeleteTeamCommand(id, version);
// Assert
result.Id.Should().Be(id);
result.Version.Should().Be(version);
}
public void ShouldHaveTeamNotFoundCustomFailureWhenIdIsGuidEmpty()
{
// Arrange
var command = new DeleteTeamCommand(id: Guid.Empty, version: 0);
// Act
var validationResult = _validator.Validate(command);
var exists =
validationResult.Errors.Any(
a => a.PropertyName.Equals("Id") && a.ErrorMessage.Contains(CustomFailures.TeamNotFound));
// Assert
exists.Should().BeTrue();
}
public async Task <ActionResult> DeleteTeamAysnc([FromQuery] DeleteTeamCommand request)
{
try
{
request.SetUser(User.GetUserId());
var response = await _mediator.Send(request);
return(Ok(response));
}
catch (Exception ex)
{
_logger.Error(ex, $"Operation failed into controller {Routes.Create_Team} with message: {ex.Message}");
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult> DeleteAsync([FromRoute] DeleteTeamCommand deleteTeamCommand)
{
try
{
await _deleteTeamCommandHandler
.HandleAsync(deleteTeamCommand)
.ConfigureAwait(false);
return(NoContent());
}
catch (EntityDoesNotExistsException)
{
return(NotFound("Team doesn't exist"));
}
}
public async Task Handle_GivenValidId_UserIsNotLeader_ThrowsNotOwnedException()
{
// Login user is member
var currentUserServiceMock = new Mock <ICurrentUserService>();
currentUserServiceMock.Setup(m => m.UserId)
.Returns(memberId.ToString());
var sut = new DeleteTeamCommandHandler(_context, currentUserServiceMock.Object);
var command = new DeleteTeamCommand {
Id = validId.ToString()
};
await Assert.ThrowsAsync <NotOwnedException>(() => sut.Handle(command, CancellationToken.None));
}
public void TestGame_DeleteTeamByUnauthorizedQuizMaster_ThrowsException()
{
// arrange
var teamId = Game.TeamIds[0]; // Team 1
var user = Users.First(u => u.UserName == "Quiz master 2");
var command = new DeleteTeamCommand {
ActorId = user.Id, TeamId = teamId
};
// act & assert
var exception = Assert.ThrowsExceptionAsync <DomainException>(() => Mediator.Send(command)).Result;
Assert.AreEqual(ResultCode.QuizMasterUnauthorizedForGame, exception.ResultCode);
Assert.AreEqual($"Actor with id {user.Id} is not authorized for game '{Game.Id}'", exception.Message);
Assert.IsTrue(exception.IsBadRequest);
}
public void TestGame_DeleteTeamWithInvalidActorId_ThrowsException()
{
// arrange
var teamId = Game.TeamIds[0]; // Team 1
var actorId = Guid.Empty.ToShortGuidString();
var command = new DeleteTeamCommand {
ActorId = actorId, TeamId = teamId
};
// act & assert
var exception = Assert.ThrowsExceptionAsync <DomainException>(() => Mediator.Send(command)).Result;
Assert.AreEqual(ResultCode.InvalidEntityId, exception.ResultCode);
Assert.AreEqual("Invalid ActorId.", exception.Message);
Assert.IsTrue(exception.IsBadRequest);
}
public void TestGame_DeleteValidTeamWithValidActorId_TeamDeleted()
{
// arrange
var teamId = Game.TeamIds[0]; // Team 1
var user = Users.First(u => u.UserName == "Quiz master 1");
var command = new DeleteTeamCommand {
ActorId = user.Id, TeamId = teamId
};
// act
Mediator.Send(command).Wait();
// assert
Assert.IsNull(UnitOfWork.GetCollection <Team>().GetAsync(teamId).Result);
CollectionAssert.DoesNotContain(UnitOfWork.GetCollection <Game>().GetAsync(Game.Id).Result.TeamIds,
teamId);
}
public async Task Should_ThrowException_When_PassTeamIdForDifferentCompany()
{
// Arrange
var team = new Team()
{
TeamName = "Test Team",
CompanyId = 2,
IsDefault = true,
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 <TeamMember> teamMemberRepository = new Repository <TeamMember>(_fixture.Context);
var handler = new DeleteTeamHandler(unitOfWork, repository, _logger, _mapper);
var request = new DeleteTeamCommand(companyId: 1, teamId: 1);
// Act
var tcs = new CancellationToken();
var exception = await Assert.ThrowsAsync <VacationTrackingException>(async() =>
{
var result = await handler.Handle(request, tcs);
});
// Assert
Assert.Equal(ExceptionMessages.ItemNotFound, exception.Message);
Assert.Equal(404, exception.Code);
}
public async Task HandleShouldReturnFailWhenDatabaseSpecificErrorOccurs()
{
// Arrange
var id = Guid.NewGuid();
var version = 1;
var teamWriteRepositoryMock = new Mock <ITeamWriteRepository>();
teamWriteRepositoryMock.Setup(x => x.DeleteAsync(id, version)).Throws <SomeDatabaseSpecificException>();
var teamWriteRepository = teamWriteRepositoryMock.Object;
var command = new DeleteTeamCommand(id, version);
var handler = new DeleteTeamCommandHandler(teamWriteRepository);
// Act
var result = await handler.Handle(command, CancellationToken.None);
// Assert
result.IsFailure.Should().BeTrue();
result.Failures.Should().OnlyContain(x => x.Message == CustomFailures.DeleteTeamFailure);
}
public async Task HandleShouldReturnOk()
{
// Arrange
var id = Guid.NewGuid();
var version = 1;
var teamWriteRepositoryMock = new Mock <ITeamWriteRepository>();
teamWriteRepositoryMock.Setup(x => x.DeleteAsync(id, version)).Returns(Task.CompletedTask);
var teamWriteRepository = teamWriteRepositoryMock.Object;
var command = new DeleteTeamCommand(id, version);
var handler = new DeleteTeamCommandHandler(teamWriteRepository);
// Act
var result = await handler.Handle(command, CancellationToken.None);
// Assert
result.IsFailure.Should().BeFalse();
result.Should().BeOfType(typeof(Result));
}
public async Task Should_ThrowException_When_PassInvalidTeamId()
{
// Arrange
IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context);
IRepository <Team> repository = new Repository <Team>(_fixture.Context);
IRepository <TeamMember> teamMemberRepository = new Repository <TeamMember>(_fixture.Context);
var handler = new DeleteTeamHandler(unitOfWork, repository, _logger, _mapper);
var request = new DeleteTeamCommand(companyId: 1, teamId: -1);
// Act
var tcs = new CancellationToken();
var exception = await Assert.ThrowsAsync <VacationTrackingException>(async() =>
{
var result = await handler.Handle(request, tcs);
});
// Assert
Assert.Equal(ExceptionMessages.ItemNotFound, exception.Message);
Assert.Equal(404, exception.Code);
}
public async Task ShouldDeleteTeamCorrectly()
{
//Arrange
var testUser = new User("test", "test", "test", "test");
var testTeam = new Team(testUser, "test", "test");
var dateDeleted = 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; dateDeleted = testTeam.ChangedAt; }).Returns(Task.CompletedTask);
var deleteTeamHandler = new DeleteTeamHandler(teamsRepository.Object);
var command = new DeleteTeamCommand(testTeam.Id);
//Act
await deleteTeamHandler.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.Deleted);
Assert.That(testTeam.ChangedAt, Is.EqualTo(dateDeleted));
}
public async Task Should_DeleteTeamWithMember_When_PassTeamId()
{
// 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 <TeamMember> teamMemberRepository = new Repository <TeamMember>(_fixture.Context);
var handler = new DeleteTeamHandler(unitOfWork, repository, _logger, _mapper);
var request = new DeleteTeamCommand(companyId: 1, teamId: 1);
// Act
var tcs = new CancellationToken();
var result = await handler.Handle(request, tcs);
// Assert
Assert.True(result);
Assert.False(teamMemberRepository.Queryable().Any(x => x.TeamId == 1));
}
public async Task HandleShouldReturnFailWhenOutdatedVersion()
{
// Arrange
var id = Guid.NewGuid();
var version = 1;
var teamWriteRepositoryMock = new Mock <ITeamWriteRepository>();
teamWriteRepositoryMock.Setup(x => x.DeleteAsync(id, version)).Throws <EntityVersionDbException>();
var teamWriteRepository = teamWriteRepositoryMock.Object;
var command = new DeleteTeamCommand(id, version);
var handler = new DeleteTeamCommandHandler(teamWriteRepository);
// Act
var result = await handler.Handle(command, CancellationToken.None);
// Assert
result.IsFailure.Should().BeTrue();
result.Failures.Should().OnlyContain(x => x.Code == HandlerFaultCode.NotMet.Name &&
x.Message == HandlerFailures.NotMet &&
x.Target == "version");
}
public async Task <ActionResult <TeamDeleteViewModel> > Delete([FromBody] DeleteTeamCommand deleteTeamCommand)
{
return(ResolveResult(await Mediator.Send(deleteTeamCommand)));
}
public async Task Delete([FromBody] DeleteTeamCommand command)
{
await CommandPublisher.ExecuteAsync(command);
}
public async Task <IActionResult> Delete([FromBody] DeleteTeamCommand command)
{
await mediator.Send(command);
return(Ok());
}
public async Task <ActionResult <bool> > DeleteTeamAsync(int id)
{
var request = new DeleteTeamCommand(id, _companyId);
return(Single(await CommandAsync(request)));
}
