public void Initialize()
{
// prepare the fakes
fakeAnalyst = new Analyst("fake", "fake", "fake");
fakeDonor = new DonorAggregate("fake");
fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "fake", "fake", DateTime.UtcNow);
// initialize the mocks behaviour
mockUnitOfWork = new Mock <IUnitOfWork>();
mockTransaction = new Mock <ITransaction>();
mockRepository = new Mock <IRepository>();
mockRepository
.Setup(x => x.Get <Analyst>())
.Returns(new[] { fakeAnalyst }.AsQueryable());
mockRepository
.Setup(x => x.Get <DonorAggregate>())
.Returns(new[] { fakeDonor }.AsQueryable());
mockRepository
.Setup(x => x.Add(It.IsAny <ProjectAggregate>()))
.Callback <ProjectAggregate>((p) => fakeProjectAggregate = p);
mockUnitOfWork
.Setup(x => x.CreateRepository())
.Returns(mockRepository.Object);
mockUnitOfWork
.Setup(x => x.BeginTransaction())
.Returns(mockTransaction.Object);
}
public void GetById_Integration_ReturnsData()
{
string filePath = Path.Combine(AppContext.BaseDirectory, Path.GetRandomFileName() + ".dbtest");
using (SQLiteDbContext dbContext = new SQLiteDbContext(filePath))
{
dbContext.Initialise();
dbContext.BeginTransaction();
IProjectRequestAggregateRepository projectRequestAggregateRepo = new ProjectRequestAggregateRepository(dbContext);
ICreateProjectCommand createProjectCommand = new CreateProjectCommand(dbContext, new ProjectValidator());
ISetLogFileUnprocessedCommand setLogFileUnprocessedCommand = Substitute.For <ISetLogFileUnprocessedCommand>();
ICreateProjectRequestAggregateCommand createProjectRequestAggregateCommand = new CreateProjectRequestAggregateCommand(dbContext, new ProjectRequestAggregateValidator(), new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
IDeleteProjectRequestAggregateCommand deleteProjectRequestAggregateCommand = new DeleteProjectRequestAggregateCommand(dbContext, projectRequestAggregateRepo, new LogFileRepository(dbContext), setLogFileUnprocessedCommand);
// create the project
ProjectModel projectA = DataHelper.CreateProjectModel();
createProjectCommand.Execute(projectA);
// create the request aggregate record for ProjectA
ProjectRequestAggregateModel projectRequestAggregate = DataHelper.CreateProjectRequestAggregateModel();
projectRequestAggregate.ProjectId = projectA.Id;
createProjectRequestAggregateCommand.Execute(projectRequestAggregate);
int id = projectRequestAggregate.Id;
Assert.Greater(id, 0);
// fetch the record
ProjectRequestAggregateModel result = projectRequestAggregateRepo.GetById(id);
Assert.IsNotNull(result);
Assert.AreEqual(projectRequestAggregate.Id, id);
Assert.AreEqual(projectRequestAggregate.RegularExpression, result.RegularExpression);
Assert.AreEqual(projectRequestAggregate.AggregateTarget, result.AggregateTarget);
}
}
public IActionResult Post([FromBody] ProjectCreateModel model)
{
var command = new CreateProjectCommand(model.Title, model.Description, new Guid(User.GetClaim("id")));
_bus.PublishCommand(command);
return(Ok());
}
public async Task CreateProjectTest()
{
_mediator.Setup(m => m.Send(It.IsAny <CreateProjectCommand>(), new System.Threading.CancellationToken()))
.Returns(Task.FromResult(new Core.ApiResponse.ApiResult
{
Code = Core.Enums.Code.Ok
}));
_authorizationService.Setup(g => g.GetUser())
.Returns(new Core.DataStructure.ControllerUser
{
UserName = "******",
UserId = 1234
});
var command = new CreateProjectCommand
{
ProjectName = "测试标题",
Desc = "测试描述",
Platform = "github"
};
var controller = new ProjectController(_mediator.Object, _log.Object, _authorizationService.Object, _projectQueries.Object);
var result = await controller.CreateProjectAsync(command);
Assert.NotNull(result);
Assert.Equal(Code.Ok, result.Code);
}
public async Task InputDataIsOk_Executed_ReturnProjectId()
{
//Arrange
var projectRepository = new Mock <IProjectRepository>();
// LÁ DO COMMANDS => PROJECTS => CREATEPROJECT
var createProjectCommand = new CreateProjectCommand
{
Title = "Título teste",
Description = "Descrição teste",
TotalCost = 5000,
IdClient = 1,
IdFreelancer = 2,
FinishedAt = DateTime.Parse("2022-04-08")
};
var createProjectCommandHandler = new CreateProjectCommandHandler(projectRepository.Object);
//Act
var id = await createProjectCommandHandler.Handle(createProjectCommand, new CancellationToken());
//Assert
Assert.True(id >= 0);
// VERIFICAR SE O MÉTODO DO REPOSITORY FOI CHAMADO
// IsAny => PADRÃO PARA SABER SE O ENTITY PROJECT FOI CHAMADO UMA VEZ "ONCE"
// It.IsAny<Project>()) É UMA SOBRECARGA LÁ NO REPOSITORY
}
public async Task TestCreateMethod()
{
// Arrange
TestLambdaContext context;
APIGatewayProxyRequest request;
APIGatewayProxyResponse response;
string json = System.Text.Json.JsonSerializer.Serialize(new
{
Title = "Hello World",
Type = ProjectType.List.ToString(),
Status = Status.Active.ToString(),
Priority = Prioritization.High.ToString(),
PercentageCompleted = 50
});
request = new APIGatewayProxyRequest
{
Headers = new Dictionary <string, string>(),
Body = json,
Path = "/projects"
};
context = new TestLambdaContext();
var functions = new CreateProjectCommand();
// Act
response = await functions.RunHandler(request, context);
// Assert
Assert.Equal(201, response.StatusCode);
Assert.Null(response.Body);
Assert.NotEmpty(response.Headers["Location"]);
}
public async void handle_ProjectCategorieslNull_test()
{
Project project = new Project();
ProjectCategory pc = null;
this._unitOfUnitMock.Setup(mock => mock.ProjectRepository.Create(It.IsAny <Project>())).Returns(project);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.CreateProjectCategory(It.IsAny <ProjectCategory>())).Returns(pc);
CreateProjectCommand command = new CreateProjectCommand(new CreateProjectModel()
{
ProjectName = "test", Categories = new List <Category>()
{
new Category()
{
CategoryId = 1, CategoryName = "test", Created = DateTime.Now, Id = 1
}
}
});
CreateProjectHandler handler = new CreateProjectHandler(this._unitOfUnitMock.Object);
var result = await handler.Handle(command, new CancellationTokenSource().Token);
Assert.False((bool)result);
}
public override async Task InitializeAsync()
{
await base.DisposeAsync();
createProjectCommand = new CreateProjectCommand("project1", true);
createProjectDto = await SendAsync(createProjectCommand);
}
private async Task <ICommandResult <Project> > CreateProject(UploadTestResultCommand command)
{
var createProjectCommand = new CreateProjectCommand(command.ProjectName);
var projectCommandResult = await _projectCommandHandler.ExecuteAsync(createProjectCommand);
return(projectCommandResult);
}
public void ShouldRequireMinimumFields()
{
var command = new CreateProjectCommand();
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
private void PopulateCreateCommand(CreateProjectCommand model, MySqlCommand command, int projectId)
{
command.Parameters.Add("@projectId", MySqlDbType.Int32).Value = projectId;
command.Parameters.Add("@name", MySqlDbType.VarChar).Value = model.Name;
command.Parameters.Add("@resume", MySqlDbType.VarChar).Value = model.Resume;
command.Parameters.Add("@openingDate", MySqlDbType.DateTime).Value = DateTime.Now;
}
public async Task <ActionResult <CreateProjectCommandResponse> > Create(
[FromBody] CreateProjectCommand createProjectCommand)
{
var response = await _mediator.Send(createProjectCommand);
return(Ok(response));
}
private DomainModel.Project CreateProject(CreateProjectCommand project)
{
int vkGroupId = this.groupInfoProvider.GetVkGroupId(project.Url);
VkGroup group = this.vkGroupRepository.GetGroupById(vkGroupId);
bool isGroupExists = group != null;
DomainModel.Project projectToCreate = new DomainModel.Project
{
Title = project.Title,
CreationDate = this.dateTimeHelper.GetDateTimeNow(),
AccountId = project.AccountId,
VkGroup = group ?? new VkGroup
{
Id = vkGroupId,
Name = this.groupInfoProvider.GetVkGroupName(project.Url),
Url = project.Url,
Type = VkGroupType.Group
}
};
using (ITransactionScope transaction = this.unitOfWorkProvider.CreateTransaction().Begin())
{
this.projectRepository.Save(projectToCreate);
if (!isGroupExists)
{
this.AddGroupRelatedData(projectToCreate);
}
transaction.Commit();
}
return(projectToCreate);
}
public async Task <CommandResponse> ExecuteAsync(CreateProjectCommand command)
{
// map project
ProjectRepository projectRepository = unitOfWork.GetRepository <Project, ProjectRepository>();
Project project = command.ServiceProvider.GetService <IMapper>()
.Map <Project>(command.CreateProjectDTO);
// insert
bool isInserted = false;
string message = "Project created";
try
{
isInserted = await projectRepository.InsertAsync(project);
await unitOfWork.SaveAsync();
}
catch (System.Exception e)
{
isInserted = false;
message = Common.Algorithms.GetFullText(e);
}
// result
return(new CommandResponse
{
IsSucessed = isInserted,
Message = message
});
}
public async Task <Result <CommandResult> > Handle(CreateProjectCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
await PublishValidationErrorsAsync(request);
return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed));
}
var project = _mapper.Map <Project>(request);
var exist = await _projectRepository.ExistByNameAsync(project.Id, project.Name);
if (exist)
{
await _mediator.Publish(new DomainNotification("", ApplicationMessages.Name_Already_Exist));
return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed));
}
await _projectRepository.CreateAsync(project);
return(Result.Success(new CommandResult(project.Id, ApplicationMessages.Create_Success)));
}
public ActionResult Create(CreateProjectViewModelPost create)
{
Request.ThrowIfDifferentReferrer();
var currentUser = _userManager.FindById(User.Identity.GetUserId());
if (ModelState.IsValid && currentUser != null &&
PathNameValidation.CheckContainsNoForbiddenPathCharacters(ModelState, nameof(create.Name), create.Name) &&
CheckProjectNameAlreadyInUse(nameof(create.Name), create.Name, currentUser) &&
SessionDefinitionValidation.CheckDefinitionTemplateJson(ModelState, nameof(create.SessionDefinitionTemplate), create.SessionDefinitionTemplate))
{
var command = new CreateProjectCommand()
{
Owner = currentUser,
SessionDefinitionTemplate = create.SessionDefinitionTemplate,
Name = create.Name,
Description = create.Description
};
_dispatcher.Dispatch(command);
return(RedirectToAction(nameof(Details), new { projectId = command.NewId }));
}
var newCreate = Mapper.Map <CreateProjectViewModel>(create);
newCreate.SessionDefinitionTemplates = GetSessionTemplatesList();
return(View(newCreate));
}
public async Task <IActionResult> CreateProject(
[FromBody] CreateProjectCommand command,
[FromServices] IMediator mediator)
{
var result = await mediator.Send(command);
return(StatusCode(200, result));
}
public async Task <IActionResult> CreateProject([FromBody] CreateProjectRequest createProjectRequest)
{
//Validate request
var createProjectCommand = new CreateProjectCommand(createProjectRequest);
var res = await Mediator.Send(createProjectCommand);
return(Ok(res));
}
public Option <SuccessResult, ErrorResult> Create(CreateProjectCommand command)
{
return(_createProjectCommandValidator
.Validate(command)
.OnSuccess(errorBuilder =>
{
_projectRepository.Insert(_mapper.Create(command));
}));
}
public async Task <IActionResult> CreateProject([FromBody] CreateProjectRequest createProjectRequest)
{
var createProjectCommand = new CreateProjectCommand(User, createProjectRequest);
var createProjectResult = await _mediator.Send(createProjectCommand);
return(createProjectResult.IsSuccess
? CreatedAtAction(nameof(GetDetails), createProjectResult.Value)
: BadRequest(createProjectResult.Error));
}
public async void handle_Exception_test()
{
Project project = new Project()
{
Id = 1
};
ProjectCategory pc = new ProjectCategory();
ProjectResearcher pr = new ProjectResearcher();
OrganisationProject op = new OrganisationProject();
this._unitOfUnitMock.Setup(mock => mock.ProjectRepository.Create(It.IsAny <Project>())).Returns(project);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.CreateProjectCategory(It.IsAny <ProjectCategory>())).Returns(pc);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.CreateProjectResearcher(It.IsAny <ProjectResearcher>()))
.Returns(pr);
this._unitOfUnitMock.Setup(mock =>
mock.RelationsRepository.CreateOrganisationProject(It.IsAny <OrganisationProject>())).Throws(new Exception());
CreateProjectCommand command = new CreateProjectCommand(
new CreateProjectModel()
{
ProjectName = "test",
Categories = new List <Category>()
{
new Category()
{
CategoryId = 1, CategoryName = "test", Created = DateTime.Now, Id = 1
}
},
ResearcherCategories = new List <ResearcherCategory>()
{
new ResearcherCategory()
{
Researcher = new Researcher()
{
Id = 1
}, Category = new Category()
{
Id = 1
}
}
},
Organisations = new List <Organisation>()
{
new Organisation()
{
Id = 1,
}
}
});
CreateProjectHandler handler = new CreateProjectHandler(this._unitOfUnitMock.Object);
var result = await handler.Handle(command, new CancellationTokenSource().Token);
Assert.Null(result);
}
public void Should_AssignCorrect_If_TypeOfProject_IsValid()
{
var expectedHandler = new CreateProjectHandler(mockUnitOfWork.Object);
fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "TaPackage", "fake", DateTime.UtcNow);
expectedHandler.Execute(fakeCommand);
fakeProjectAggregate.ProjectType.Should().Be(TypeOfProject.TaPackage);
}
public async Task <ProjectGetResponseModel> Post([FromBody] CreateProjectCommand command, [FromHeader(Name = "X-Request-Id")] string?requestId)
{
requestId ??= Activity.Current?.Id ?? HttpContext.TraceIdentifier;
var identifiedCommand = new IdentifiedCommand <CreateProjectCommand, ProjectGetResponseModel>(command, requestId);
ProjectGetResponseModel result = await _mediator.Send(identifiedCommand);
return(result);
}
public void Should_AssignCorrect_If_TypeOfTender_IsValid()
{
var expectedHandler = new CreateProjectHandler(mockUnitOfWork.Object);
fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "fake", "NegotiatedProcedure", DateTime.UtcNow);
expectedHandler.Execute(fakeCommand);
fakeProjectAggregate.TenderProcessType.Should().Be(TypeOfTenderProcess.NegotiatedProcedure);
}
public async Task <IActionResult> CreateProjectAsync([FromBody] Domain.AggregatesModel.Project project)
{
var command = new CreateProjectCommand()
{
Project = project
};
var result = await _mediator.Send(command);
return(Ok(result));
}
public async Task <IActionResult> CreatProject([FromBody] Zhengwei.Project.Domain.AggregatesModel.Project project)
{
var command = new CreateProjectCommand()
{
Project = project
};
var pro = await _mediator.Send(command);
return(Ok(pro));
}
public async Task <IActionResult> CreateProject([FromBody] CreateProjectCommand createProjectCommand)
{
var commandResult = await _projectCommandHandler.ExecuteAsync(createProjectCommand);
if (commandResult.Success)
{
return(Ok(commandResult.Result));
}
return(BadRequest(createProjectCommand));
}
public void Initialize()
{
// prepare the fakes
fakeAnalyst = new Analyst("fake", "fake", "fake");
fakeDonor = new DonorAggregate("fake");
fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "fake", "fake", DateTime.UtcNow);
// initialize the mocks behaviour
mockUnitOfWork = new Mock <IUnitOfWork>();
mockRepository = new Mock <IRepository>();
}
public ActionResult Create(CreateProjectCommand command)
{
if (!ModelState.IsValid)
{
return(View(command));
}
command.CreatedByUserId = User.Identity.GetUserId();
PipelineService.HandleCommand(command);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> CreateProject(CreateProjectCommand createProjectCommand)
{
await _mediator.Publish(
new CreateProjectCommand
{
Key = createProjectCommand.Key.ToUpper(),
Name = createProjectCommand.Name
});
return(Ok());
}
