public async Task <PersonaViewModel> Create(CreatePersonaCommand command)
{
//send command to broker
var result = await producer.Send <CreatePersonaCommand, Persona>(command);
return(mapper.Map <PersonaViewModel>(result));
}
public async Task <Persona> Create()
{
var name = "Persona Test";
var command = new CreatePersonaCommand(name);
return(await Create(command));
}
public async Task <PersonaViewModel> Create()
{
var name = "Persona 0001";
var command = new CreatePersonaCommand(name);
return(await Create(command));
}
public async Task <PersonaViewModel> Create(CreatePersonaCommand command)
{
var response = await controller.Create(command) as CreatedResult;
var viewmodel = response.Value as PersonaViewModel;
return(viewmodel);
}
public PersonaViewModel Create(CreatePersonaCommand command)
{
return(mapper
.Map <PersonaViewModel>(
messageBus
.DispatchCommandTwoWay <CreatePersonaCommand, Persona
>(command).Result));
}
public PersonaViewModel Create()
{
var name = "Student";
var command = new CreatePersonaCommand(name);
return(Create(command));
}
public async Task <PersonaViewModel> Create(CreatePersonaCommand command)
{
//arrange
const int expectedNumberOfErrors = 0;
//act
var response = await appService.Create(command);
//assert
command.ValidateModelAnnotations().Count.Should().Be(expectedNumberOfErrors);
response.Id.Should().NotBe(Guid.Empty);
response.Name.Should().Be(command.Name);
return(response);
}
public void WhenCreateNewEmpty_Then_Error()
{
//arrange
var name = "";
var command = new CreatePersonaCommand(name);
//act
Action action = () => { factory.Create(command); };
//assert
action.Should()
.Throw <ModelException>()
.WithMessage(
"This object instance is not valid based on DataAnnotation definitions. See more details on Errors list.");
}
public void WhenCreateWithNoName_Then_Error()
{
//arrange
var expectedNumberOfErrors = 1;
var name = "";
var command = new CreatePersonaCommand(name);
//act
Action action = () => { factory.Create(command); };
//assert
action.Should()
.Throw <ModelException>()
.Where(x => x.Errors.Count() == expectedNumberOfErrors);
}
private async Task <ApiResponse> Create(CreatePersonaCommand command)
{
// Arrange
var requestBody =
new StringContent(JsonConvert.SerializeObject(command), Encoding.UTF8, "application/json");
// Act
var response = await client.PostAsync(url, requestBody);
// Assert
var apiResponse = JsonConvert.DeserializeObject <ApiResponse>(await response.Content.ReadAsStringAsync());
apiResponse.StatusCode.Should().Be((int)HttpStatusCode.OK);
apiResponse.ResponseException.Should().BeNull();
apiResponse.Message.Should().Be("Request successful.");
return(apiResponse);
}
private async Task <PersonaViewModel> Create(CreatePersonaCommand command)
{
// Arrange
var requestBody =
new StringContent(JsonConvert.SerializeObject(command), Encoding.UTF8, "application/json");
// Act
var response = await client.PostAsync(url, requestBody);
// Assert
var apiResponse = JsonConvert.DeserializeObject <PersonaViewModel>(await response.Content.ReadAsStringAsync());
response.StatusCode.Should().Be((int)HttpStatusCode.Created);
//apiResponse.IsSuccessRequest.Should().BeTrue();
//apiResponse.Message.Should().Be(HttpStatusCode.Created.ToString());
return(apiResponse);
}
public async Task <Persona> Create(CreatePersonaCommand command)
{
var datetime = DateTime.Now;
var company = new Persona();
company.Create(command);
//act
await repository.Insert(company);
await unitOfWork.Commit();
//assert
company.Id.Should().NotBe(Guid.Empty);
company.Name.Should().Be(command.Name);
company.CreateDate.ToShortDateString().Should().Be(datetime.ToShortDateString());
company.ModifiedDate.Should().BeNull();
company.ToString().Should().Be($"Type:{company.GetType().Name} - Id:{company.Id}");
return(company);
}
public void WhenCreateNotValidEntity_Then_Error()
{
//arrange
var expectedNumberOfErrors = 1;
var name = string.Empty;
var command = new CreatePersonaCommand(name);
//act
Func <Task> action = async() => { await factory.Create(command); };
//assert
action.Should()
.Throw <ModelException>()
.Where(x => x.Errors.Count() == expectedNumberOfErrors);
action.Should()
.Throw <ModelException>()
.WithMessage(
"This object instance is not valid based on DataAnnotation definitions. See more details on Errors list.");
}
public async Task <ActionResult <int> > Create([FromBody] CreatePersonaCommand command, CancellationToken cancellationToken)
{
var personaId = await CreatePersonaHandler.Handle(command, _context, cancellationToken);
return(Ok(personaId));
}
public async Task <IActionResult> Create([FromBody] CreatePersonaCommand command)
{
var result = await appService.Create(command);
return(Created(result.Id.ToString(), result));
}
public void Create(CreatePersonaCommand command)
{
Name = command.Name;
AppliedEvents.Add(new PersonaCreatedEvent(this, command.MessageId));
}
public IActionResult Post([FromBody] CreatePersonaCommand command)
{
return(Ok(appService.Create(command)));
}
