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