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))); }