private async Task <Guid> CreateTestFlowAsync()
{
string testName = SharedConsoleFlows.AskForString("What is the name of the test?");
byte numberOfVersions = SharedConsoleFlows.AskForByte("How many versions are there?");
byte minimumGrade = SharedConsoleFlows.AskForByte("What is the minimum grade?");
byte standardizationFactor = SharedConsoleFlows.AskForByte("What is the standardization factor?");
var createTestRequest = new CreateTestRequest()
{
Name = testName,
MinimumGrade = minimumGrade,
StandardizationFactor = standardizationFactor,
NumberOfVersions = numberOfVersions
};
CreateTestResult createTestResponse = await _testController.CreateTestAsync(createTestRequest);
Guid testId = createTestResponse.TestId;
if (createTestResponse.ValidationMessages.Any())
{
SharedConsoleFlows.PrintValidationMessages(createTestResponse.ValidationMessages);
testId = await CreateTestFlowAsync();
}
return(testId);
}
public async Task <BaseResponse <Test> > CreateItemAsync(CreateTestRequest request)
{
BaseResponse <Test> CreateItemResponse = new BaseResponse <Test>();
try
{
var Dictionary = new Dictionary <string, string>();
//some user create business logics
CreateItemResponse.Data = new Test {
Key = "1", Value = "Test Value"
}; // User id
await Control.Publish(new TestValueAddEvent
{
Key = "1",
Value = "Test Value"
});
}
catch (Exception ex)
{
CreateItemResponse.Errors.Add(ex.Message);
Logger.LogError(ex, ex.Message);
}
return(CreateItemResponse);
}
public void Validate_ModelNull_ThrowsException()
{
CreateTestRequest input = null;
Action action = () => _sut.Validate(input);
action.Should().Throw <ArgumentNullException>();
}
public async Task <HttpResponseMessage> CreateTest(CreateTestRequest request)
{
await
_commandDispatcher.Dispatch(
new VisitorUserSession(),
new CreateTest(request.Name));
return(Request.CreateResponse(HttpStatusCode.Accepted, "Accepted"));
}
public void Validate_ValidName_ReturnsNull()
{
CreateTestRequest input = _fixture.Build <CreateTestRequest>()
.With(x => x.Name, _fixture.Create <string>())
.Create();
Application.Validation.ValidationMessage result = _sut.Validate(input);
result.Should().BeNull();
}
public async Task <HttpResponseMessage> Create([FromBody] TestDto test)
{
var request = new CreateTestRequest
{
Test = test
};
await _mediator.ExecuteAsync(request).ConfigureAwait(false);
return(Request.CreateResponse(HttpStatusCode.Created));
}
public void Validate_InvalidName_ReturnsValidationMessage()
{
CreateTestRequest input = _fixture.Build <CreateTestRequest>()
.With(x => x.Name, string.Empty)
.Create();
Application.Validation.ValidationMessage result = _sut.Validate(input);
result.Should().NotBeNull();
result.Field.Should().Be("Name");
result.Message.Should().Be("Name is required");
}
public async Task <IActionResult> Post([FromBody] CreateTestRequest request)
{
BaseResponse <Test> createUserResponse = await Service.CreateItemAsync(request);
if (!createUserResponse.HasError)
{
return(Created("test", createUserResponse.Data));
}
else
{
return(BadRequest(createUserResponse.Errors));
}
}
/// <inheritdoc/>
public async Task <CreateTestResult> CreateTestAsync(CreateTestRequest model)
{
IEnumerable <ValidationMessage> validationMessages = _testValidator.ValidateRules(model);
if (validationMessages.Any())
{
return(new CreateTestResult(validationMessages));
}
var test = new Test(Name.CreateFromString(model.Name),
StandardizationFactor.CreateFromByte(model.StandardizationFactor),
Grade.CreateFromByte(model.MinimumGrade),
model.NumberOfVersions);
await _testRepository.CreateAsync(test);
return(new CreateTestResult(test.Id));
}
public async Task CreateTestAsync_WithValidRequest_CreatesClass()
{
CreateTestRequest input = CreateDefaultTestRequest();
var validationMessages = _fixture.CreateMany <ValidationMessage>(0);
_testValidator
.Setup(x => x.ValidateRules(input))
.Returns(validationMessages);
CreateTestResult result = await _sut.CreateTestAsync(input);
result.TestId.Should().NotBeEmpty();
result.ValidationMessages.Should().BeEmpty();
_testRepository
.Verify(x => x.CreateAsync(It.Is <Test>(x => x.Name.Value == input.Name)));
}
public async Task <IActionResult> Create([FromBody] CreateTestRequest testRequest)
{
var newTestId = Guid.NewGuid();
var test = new Test {
Number = testRequest.Number,
Text = testRequest.Text,
Tags = testRequest.Tags.Select(x => new TestTag {
TestId = newTestId, TagName = x
}).ToList(),
Date = DateTime.Now,
UserId = HttpContext.GetUserId()
};
await _testService.CreateTestAsync(test);
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUri = baseUrl + "/" + ApiRoutes.BareBase + "/test/" + test.ID.ToString();
var response = new TestResponse {
ID = test.ID
};
return(Created(locationUri, response));
}
protected async Task <TestResponse> CreateTestAsync(CreateTestRequest request)
{
var response = await TestClient.PostAsJsonAsync($"{ApiRoutes.Base}/test", request);
return(await response.Content.ReadAsAsync <TestResponse>());
}
