public async Task Start_WhenBeforeTicketUpdatedWorkflowIsNotSuccessful_VerifyFactoryWorkflowFailedIsCalled() { var ticketId = _fixture.Create <int>(); var updateTicket = new UpdateTicketDto(); var mockWorkflow = new Mock <BeforeTicketUpdatedWorkflow>(It.IsAny <int>(), It.IsAny <IReadOnlyDictionary <string, ValueChange> >()); var mockRepository = new Mock <IContextRepository <ITicketContext> >(); var mockWorkflowService = new Mock <IWorkflowService>(); var mockFactory = new Mock <IUpdateTicketResultFactory>(); var mockValidator = new Mock <IValidator <UpdateTicketDto> >(); var mockValidationResult = new Mock <ValidationResult>(); mockWorkflow.Setup(a => a.Result).Returns(WorkflowResult.Failed); mockRepository.Setup(s => s.SingleAsync(It.IsAny <GetTicketById>())).ReturnsAsync(new Ticket()); mockWorkflowService.Setup(s => s.Process(It.IsAny <BeforeTicketUpdatedWorkflow>())).ReturnsAsync(mockWorkflow.Object); mockValidator.Setup(m => m.ValidateAsync(updateTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object); mockValidationResult.Setup(m => m.IsValid).Returns(true); var service = CreateService( mockRepository: mockRepository, mockWorkflowService: mockWorkflowService, mockFactory: mockFactory, mockValidator: mockValidator); await service.Update(ticketId, updateTicket); mockFactory.Verify(v => v.WorkflowFailed(ticketId, mockWorkflow.Object), Times.Once, "Should return the factory's WorkflowFailed method."); }
public async Task Open_WhenTicketIsAdded_VerifyTickeUpdatedNotificationIsQueued() { var ticketId = _fixture.Create <int>(); var updateTicket = new UpdateTicketDto(); var ticket = new Ticket(); var mockRepository = new Mock <IContextRepository <ITicketContext> >(); var mockWorkflowService = new Mock <IWorkflowService>(); var mockNotificationService = new Mock <INotificationService>(); var mockMapper = new Mock <IMapper>(); var mockValidator = new Mock <IValidator <UpdateTicketDto> >(); var mockValidationResult = new Mock <ValidationResult>(); mockWorkflowService.Setup(s => s.Process(It.IsAny <BeforeTicketUpdatedWorkflow>())).ReturnsAsync(new BeforeTicketUpdatedWorkflow(ticketId, It.IsAny <IReadOnlyDictionary <string, ValueChange> >())); mockValidator.Setup(m => m.ValidateAsync(updateTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object); mockValidationResult.Setup(m => m.IsValid).Returns(true); mockRepository.Setup(m => m.SingleAsync(It.IsAny <GetTicketById>())).ReturnsAsync(ticket); mockMapper.Setup(m => m.Map <Ticket>(updateTicket)).Returns(ticket); var service = CreateService( mockRepository: mockRepository, mockWorkflowService: mockWorkflowService, mockMapper: mockMapper, mockNotificationService: mockNotificationService, mockValidator: mockValidator); var result = await service.Update(ticketId, updateTicket); mockNotificationService.Verify(v => v.Queue(It.Is <TicketUpdatedNotification>(a => a.TicketId == ticketId)), Times.Once, "Should queue a new TicketUpdatedNotification."); }
public void NullObjectReturnsNull() { UpdateTicketDto dto = null; var item = _mapper.Map <Ticket>(dto); Assert.IsNull(item); }
public async Task Update_BeforeTicketIsUpdated_VerifyBeforeTicketUpdatedWorkflowIsProcessed() { var ticketId = _fixture.Create <int>(); var updateTicket = new UpdateTicketDto(); var ticket = new Ticket(); var mockRepository = new Mock <IContextRepository <ITicketContext> >(); var mockWorkflowService = new Mock <IWorkflowService>(); var mockFactory = new Mock <IUpdateTicketResultFactory>(); var mockValidator = new Mock <IValidator <UpdateTicketDto> >(); var mockValidationResult = new Mock <ValidationResult>(); mockValidator.Setup(m => m.ValidateAsync(updateTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object); mockValidationResult.Setup(m => m.IsValid).Returns(true); mockRepository.Setup(m => m.SingleAsync(It.IsAny <GetTicketById>())).ReturnsAsync(ticket); mockWorkflowService.Setup(s => s.Process(It.IsAny <BeforeTicketUpdatedWorkflow>())).ReturnsAsync(new BeforeTicketUpdatedWorkflow(ticketId, It.IsAny <IReadOnlyDictionary <string, ValueChange> >())); var service = CreateService( mockRepository: mockRepository, mockWorkflowService: mockWorkflowService, mockValidator: mockValidator); await service.Update(ticketId, updateTicket); mockWorkflowService.Verify(v => v.Process(It.Is <BeforeTicketUpdatedWorkflow>(w => w.TicketId == ticketId)), Times.Once, "Should call the workflow flow's Process method for BeforeTicketUpdatedWorkflow."); }
public void WhenUpdateDueDateIsFalse_DoesNotMapDueDate() { var dto = new UpdateTicketDto { DueDate = _fixture.Create <DateTimeOffset>(), UpdateDueDate = false }; var ticket = _mapper.Map <Ticket>(dto); Assert.AreNotEqual(dto.DueDate, ticket.DueDate); }
public void WhenUpdateDueDateIsTrue_MapsDueDate() { var dto = new UpdateTicketDto { DueDate = _fixture.Create <DateTimeOffset?>(), UpdateDueDate = true }; var ticket = _mapper.Map <Ticket>(dto); Assert.AreEqual(dto.DueDate, ticket.DueDate); }
public IActionResult Patch(string id, [FromBody] UpdateTicketDto model) { if (model == null) { return(BadRequest("No data")); } if (string.IsNullOrEmpty(model.Showing)) { return(BadRequest("No Showing")); } if (string.IsNullOrEmpty(model.User)) { return(BadRequest("No User")); } if (model.FieldX == 0) { return(BadRequest("No fieldX")); } if (model.FieldY == 0) { return(BadRequest("No fieldY")); } var user = _crudUsers.GetItem(model.User); var show = _crudShowings.GetItem(model.Showing); var placeIsFree = _crud.CheckIfCanUpdate(model.FieldX, model.FieldY, id, model.Showing); if (!placeIsFree) { return(BadRequest("Slot taken")); } var ticket = new Tickets { Showing = show, User = user, FieldX = model.FieldX, FieldY = model.FieldY, Status = model.Status, }; var entity = _crud.UpdateItem(id, ticket); return(Ok(new { ticket = entity })); }
public async Task Open_VerifySingleAsyncForGetTicketByIdIsCalled() { var ticketId = _fixture.Create <int>(); var updateTicket = new UpdateTicketDto(); var mockRepository = new Mock <IContextRepository <ITicketContext> >(); var mockValidator = new Mock <IValidator <UpdateTicketDto> >(); var mockValidationResult = new Mock <ValidationResult>(); mockValidator.Setup(m => m.ValidateAsync(updateTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object); mockValidationResult.Setup(m => m.IsValid).Returns(true); var service = CreateService( mockRepository: mockRepository, mockValidator: mockValidator); var result = await service.Update(ticketId, updateTicket); mockRepository.Verify(v => v.SingleAsync(It.Is <GetTicketById>(c => c._ticketId == ticketId)), Times.Once, "Should call the context's SingleAsync method exactly once for GetTicketById."); }
public async Task Open_WhenUpdateTicketDtoIsNotValid_VerifyFactoryValidationFailureIsReturned() { var ticketId = _fixture.Create <int>(); var updateTicket = new UpdateTicketDto(); var mockFactory = new Mock <IUpdateTicketResultFactory>(); var mockValidator = new Mock <IValidator <UpdateTicketDto> >(); var mockValidationResult = new Mock <ValidationResult>(); mockValidator.Setup(m => m.ValidateAsync(updateTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object); mockValidationResult.Setup(m => m.IsValid).Returns(false); var service = CreateService( mockFactory: mockFactory, mockValidator: mockValidator); var result = await service.Update(ticketId, updateTicket); mockFactory.Verify(v => v.ValidationFailure(ticketId, mockValidationResult.Object.Errors), Times.Once, "Should return the factory's ValidationFailure method."); }
public IActionResult ReassignTicket(UpdateTicketDto data) { var ticket = _ticketUoW.Tickets.GetByID(data.TicketId); ticket.AssignedTo = data.FieldId; var timeline = new Timeline() { TicketId = ticket.TicketId, DoneBy = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value), Action = "reassigned", ActionDate = DateTime.Now }; _ticketUoW.Timeline.Insert(timeline); _ticketUoW.Tickets.Update(ticket); _ticketUoW.Save(); return(NoContent()); }
public void MapsOpenTicketDtoToTicket() { var dto = new UpdateTicketDto { Name = _fixture.Create <string>(), Description = _fixture.Create <string>(), Severity = _fixture.Create <Severity?>(), Priority = _fixture.Create <Priority?>(), }; var ticket = _mapper.Map <Ticket>(dto); Assert.Multiple(() => { Assert.IsNotNull(ticket); Assert.IsInstanceOf <Ticket>(ticket); Assert.AreEqual(dto.Name, ticket.Name); Assert.AreEqual(dto.Description, ticket.Description); Assert.AreEqual(dto.Severity, ticket.Severity); Assert.AreEqual(dto.Priority, ticket.Priority); }); }
public async Task Open_WhenClientRecordIsNull_VerifyFactoryTicketNotFoundIsReturned() { var ticketId = _fixture.Create <int>(); var updateTicket = new UpdateTicketDto(); var mockRepository = new Mock <IContextRepository <ITicketContext> >(); var mockFactory = new Mock <IUpdateTicketResultFactory>(); var mockValidator = new Mock <IValidator <UpdateTicketDto> >(); var mockValidationResult = new Mock <ValidationResult>(); mockValidator.Setup(m => m.ValidateAsync(updateTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object); mockValidationResult.Setup(m => m.IsValid).Returns(true); mockRepository.Setup(m => m.SingleAsync(It.IsAny <GetTicketById>())).ReturnsAsync((Ticket)null); var service = CreateService( mockRepository: mockRepository, mockFactory: mockFactory, mockValidator: mockValidator); var result = await service.Update(ticketId, updateTicket); mockFactory.Verify(v => v.TicketNotFound(ticketId), Times.Once, "Should return the factory's TicketNotFound method."); }
public virtual async Task <UpdateTicketResult> Update(int ticketId, UpdateTicketDto updateTicket) { if (updateTicket == null) { throw new ArgumentNullException(nameof(updateTicket)); } var validationResult = await _validator.ValidateAsync(updateTicket); if (!validationResult.IsValid) { return(_factory.ValidationFailure(ticketId, validationResult.Errors)); } var ticket = await _repository.SingleAsync(new GetTicketById(ticketId)); if (ticket == null) { return(_factory.TicketNotFound(ticketId)); } var changes = updateTicket.GetChanges(ticket); var beforeWorkflow = await _workflowService.Process(new BeforeTicketUpdatedWorkflow(ticketId, changes)); if (beforeWorkflow.Result != WorkflowResult.Succeeded) { return(_factory.WorkflowFailed(ticketId, beforeWorkflow)); } _mapper.Map(updateTicket, ticket); await _repository.SaveAsync(); var workflow = _workflowService.Process(new TicketUpdatedWorkflow(ticketId, changes)); var notification = _notificationService.Queue(new TicketUpdatedNotification(ticketId, changes)); await Task.WhenAll(workflow, notification); return(_factory.Updated(ticket, changes)); }
public IActionResult ChangeTicketStatus(UpdateTicketDto data) { var ticket = _ticketUoW.Tickets.GetByID(data.TicketId); ticket.StatusId = data.FieldId; _ticketUoW.Tickets.Update(ticket); var status = _ticketUoW.Status.GetByID(data.FieldId); var timeline = new Timeline() { TicketId = ticket.TicketId, DoneBy = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value), Action = status.Description.ToLower(), ActionDate = DateTime.Now }; _ticketUoW.Timeline.Insert(timeline); _ticketUoW.Save(); return(NoContent()); }