public async Task GivenCreateIssueCommand_ReturnNewIssueId()
{
// Arrange
var command1 = new CreateIssueCommand
{
Title = "Harry Potter & the philosopher's stone",
Prefix = "ENG",
Description = "Read the book"
};
var command2 = new CreateIssueCommand
{
Title = "A Game of Thrones",
Prefix = "ENG",
Description = "Read the book"
};
// Act
var content1 = Utilities.GetRequestContent(command1);
var response1 = await _client.PostAsync("api/issue/new", content1);
var result1 = await response1.Content.ReadAsStringAsync();
var content2 = Utilities.GetRequestContent(command2);
var response2 = await _client.PostAsync("api/issue/new", content2);
var result2 = await response2.Content.ReadAsStringAsync();
//Assert
response1.EnsureSuccessStatusCode();
response2.EnsureSuccessStatusCode();
Assert.Equal("ENG-3", result1);
Assert.Equal("ENG-4", result2);
}
public void ShouldRequireMinimumFields()
{
var command = new CreateIssueCommand();
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
public async Task ShouldNotHaveStoryPointAndStepToReproduceTogether()
{
var userId = RunAsDefaultUser();
var projectId = await SendAsync(new CreateProjectCommand
{
Key = "TKWZ",
Name = "Test Project",
OwnerId = userId
});
var command = new CreateIssueCommand
{
Assignee = userId,
Title = "Tasks",
Type = IssueType.Bug,
ProjectId = projectId,
Reporter = userId,
StoryPoint = 5,
StepsToReplicate = "-StepsToReplicate-"
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
public async Task ShouldCreateIssueSuccessfully()
{
var userId = RunAsDefaultUser();
var projectId = await SendAsync(new CreateProjectCommand
{
Key = "TKWZ",
Name = "Test Project",
OwnerId = userId
});
var command = new CreateIssueCommand
{
Assignee = userId,
Title = "Tasks",
Type = IssueType.Task,
ProjectId = projectId,
Reporter = userId
};
var itemId = await SendAsync(command);
var item = await FindAsync <Issue>(itemId);
item.Should().NotBeNull();
item.Title.Should().Be(command.Title);
item.CreatedBy.Should().Be(userId);
item.CreatedDate.Should().BeCloseTo(DateTime.Now, 10000);
item.LastModifiedBy.Should().BeNull();
item.LastModified.Should().BeNull();
}
public CreateIssueResponse CreateIssue(CreateIssueCommand createIssue)
{
Project project = this._projectRepository.FindByID(createIssue.ProjectID);
Issue issue = new Issue
{
Key = GenerateIssueKey(project, this._issueRepository),
AssigneeID = createIssue.AssigneeID,
Attachment = createIssue.Attachment,
Description = createIssue.Description,
IssueTypeID = createIssue.IssueTypeID,
PriorityID = createIssue.PriorityID,
ProjectID = createIssue.ProjectID,
ReporterID = createIssue.ReporterID,
SprintID = createIssue.SprintID,
Summary = createIssue.Summary
};
if (this._issueRepository.FindByKey(issue.Key) == null)
{
this._issueRepository.Save(issue);
}
return(new CreateIssueResponse
{
IssueKey = issue.Key,
ProjectID = project.ID.ToString()
});
}
public ActionResult <Issue> Create(CreateIssueCommand createIssueCommand)
{
_createIssueCommandValidator.Validate(createIssueCommand);
var createdIssueId = _createIssueOperationService.Create(createIssueCommand);
return(Get(createdIssueId));
}
public void ShouldBeTrue_WhenSummaryIsNotEmpty()
{
var command = new CreateIssueCommand("summary", 21);
var validator = new CreateIssueCommandValidator();
var result = validator.Validate(command);
result.IsValid.ShouldBe(true);
}
public void ShouldBeFalse_WheIssueTypeIsEmpty()
{
var command = new CreateIssueCommand("summary", 0);
var validator = new CreateIssueCommandValidator();
var result = validator.Validate(command);
result.IsValid.ShouldBe(false);
}
private void GivenACommand()
{
_command = new CreateIssueCommand
{
Title = Guid.NewGuid().ToString(),
Description = Guid.NewGuid().ToString(),
MediaType = PlexMediaTypes.Movie,
TheMovieDbId = new Random().Next(1, int.MaxValue)
};
}
public long Create(CreateIssueCommand command)
{
using (var scope = new TransactionScope())
{
var createdOn = DateTime.Now;
var createdIssueId = _repository.Create(new Issue(command.Title, command.Notes, createdOn, modifiedOn: createdOn));
scope.Complete();
return(createdIssueId);
}
}
public async Task <IActionResult> Create([FromBody] CreateIssueCommand command)
{
try
{
var output = await Mediator.Send(command);
return(Ok(output));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <IActionResult> CreateIssue([FromBody] CreateIssueCommand createIssueCommand)
{
await _mediator.Publish(
new CreateIssueCommand
{
ProjectId = createIssueCommand.ProjectId,
Description = createIssueCommand.Description,
Title = createIssueCommand.Title,
Type = createIssueCommand.Type,
Status = createIssueCommand.Status,
});
return(Ok());
}
public void Handle_NotFoundCategory_ShouldThrowArgException()
{
// Arrange
var handler = new CreateIssueCommandHandler(GetCategoryRepository().Object, GetMapper());
var request = new CreateIssueCommand
{
CategoryId = 2,
IssueName = "Clean up room"
};
// Act
var del = new AsyncTestDelegate(() => handler.Handle(request, CancellationToken.None));
// Assert
Assert.ThrowsAsync <System.ArgumentException>(del);
}
public async Task ShouldAddProjectIssue()
{
var participantUserId = await RunAsUserAsync("participant@local", "Testing1234!", new string[] { });
var participant = new Participant(participantUserId, "participant firstName", "participant lastName");
var ownerUserId = await RunAsUserAsync("owner@local", "Testing1234!", new string[] { });
var owner = new Participant(ownerUserId, "owner firstName", "owner lastName");
//await AddAsync(participant);
var entity = new Project(owner, "Project Name", "Key");
entity.AddParticipant(participant);
await AddAsync(entity);
var command = new CreateIssueCommand
{
ProjectId = entity.Id,
IssueType = IssueType.Task,
Description = "Description",
Title = "Title",
Status = IssueStatus.Todo,
AssigneeId = participant.Id
};
var id = await SendAsync(command);
using var scope = _scopeFactory.CreateScope();
var context = scope.ServiceProvider.GetService <ApplicationDbContext>();
var project = await context.Projects
.Include(x => x.Participants)
.Include(x => x.Issues)
.SingleOrDefaultAsync(x => x.Id == entity.Id);
project.Should().NotBeNull();
project.Participants.Last().Id.Should().Be(participant.Id);
project.Issues.First().Description.Should().Be(command.Description);
project.Issues.First().Title.Should().Be(command.Title);
project.Issues.First().Type.Should().Be(command.IssueType);
project.Issues.First().Status.Should().Be(command.Status);
project.CreatedBy.Should().Be(ownerUserId);
project.Created.Should().BeCloseTo(DateTime.Now, 20000);
}
public CreateIssueCommandTests()
{
_currentUserId = "1a";
var currentUserService = new Mock <ICurrentUserService>();
currentUserService.Setup(x => x.GetUserId()).Returns(_currentUserId);
var context = ContextFactory.CreateInMemoryContext(currentUserService.Object);
_issueTypeRepository = new IssueTypeRepository(context);
_issueRepository = new IssueRepository(context);
_issueStateRepository = new IssueStateRepository(context);
SeedDataTest();
_handler = new CreateIssueCommandHandler(currentUserService.Object, _issueRepository, _issueStateRepository);
_request = new CreateIssueCommand("Summary 1", _issueType.Id);
}
public async void Initialize()
{
Project = navigationService.GetNavigationParameter() as Project;
if (Project == null)
{
dialogService.ShowDialog(AppResources.CreateIssueNullProjectMessage, AppResources.Error);
return;
}
CreateIssueCommand.RaiseCanExecuteChanged();
IssueTypes = await jiraService.GetIssueTypesOfProject(Project.Key);
PriorityList = await jiraService.GetPriorities();
LoadingText = AppResources.LoadingMessage;
MessengerInstance.Send(false, "TaskBarVisibility");
}
public async Task Handle_NewIssue_ShouldSaveNewIssue()
{
// Arrange
var categoryRepositoryMock = GetCategoryRepository();
var handler = new CreateIssueCommandHandler(categoryRepositoryMock.Object, GetMapper());
var request = new CreateIssueCommand
{
CategoryId = 1,
IssueName = "Clean out room"
};
// Act
await handler.Handle(request, CancellationToken.None);
// Assert
categoryRepositoryMock.Verify(x => x.SaveCategory(It.IsAny <Category>()), Times.Once);
}
public void GivenCommandWithData_WhenCommandIsSendToApplicationService_ThenWriteModelIsChanged()
{
var serviceLocator = new ServiceLocator();
var writeModel = new AppWriteModel();
var commandHandler = new CreateIssueCommandHandler(writeModel);
serviceLocator.RegisterCommandHandler <CreateIssueCommand, CreateIssueCommandHandler>(commandHandler);
var applicationService = new IssueApplicationService(new CommandBus(serviceLocator.GetMediator()));
//Given
var createdIssueName = "cleaning";
var command = new CreateIssueCommand(createdIssueName);
//When
applicationService.CreateIssue(command);
//Then
writeModel.Issues.Should().Have.Count.EqualTo(1);
writeModel.Issues.Should().Have.SameValuesAs(createdIssueName);
}
public Task CreateIssue(CreateIssueCommand command)
{
return(commandBus.Send(command));
}
// POST api/<controller>
public void Post(CreateIssueCommand command)
{
_createIssueCommandHandler.Handle(command);
}
public async Task <ActionResult <int> > Create(CreateIssueCommand command)
{
return(await Mediator.Send(command));
}
public ActionResult CreateIssue(CreateIssueCommand command)
{
var response = this._issueService.CreateIssue(command);
return(Json(response));
}
public async Task <ActionResult <int> > Create(CreateIssueRequest request, CancellationToken cancellationToken)
{
var command = new CreateIssueCommand(request.Summary, request.IssueTypeId);
return(await _mediator.Send(command, cancellationToken));
}
public async Task <IActionResult> New(CreateIssueCommand command)
{
var result = await Mediator.Send(command);
return(Ok(result));
}
public async Task <ActionResult> CreateIssue([FromBody] CreateIssueCommand command)
{
var result = await _mediator.Send(command);
return(result.ToOkIfValidResult());
}
public async Task <ActionResult <string> > AddAsync([FromBody] CreateIssueCommand request)
{
return(await this.Mediator.Send(request));
}
public async Task <CreateIssueCommandResult> Create(CreateIssueCommand command)
{
return(await commandDispatcher.Dispatch <CreateIssueCommand, CreateIssueCommandResult>(command));
}
