public void given_a_valid_postInitialProcessDocumentRequest_when_postInitialProcessDocument_controller_method_is_called_then_the_controller_returns_correct_json_response()
{
//arange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
_mockValidatorPost.Setup(v => v.Validate(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(new FV.ValidationResult()); //set up mock validation to return Validation with no errors.
var expectedResponse = new PostInitialProcessDocumentResponse(requestObject, requestObject.processRef, DateTime.Now);
_mockUsecase.Setup(g => g.ExecutePost(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(expectedResponse);
////act
var actualResponse = _processDataController.PostInitialProcessDocument(requestObject);
var result = (ObjectResult)actualResponse;
var resultContent = (PostInitialProcessDocumentResponse)result.Value;
////assert
Assert.NotNull(actualResponse);
Assert.NotNull(result);
Assert.IsInstanceOf <PostInitialProcessDocumentResponse>(resultContent);
Assert.NotNull(resultContent);
Assert.AreEqual(expectedResponse.ProcessRef, resultContent.ProcessRef);
Assert.AreEqual(expectedResponse.GeneratedAt, resultContent.GeneratedAt);
Assert.AreEqual(expectedResponse.Request.processRef, resultContent.Request.processRef);
Assert.AreEqual(JsonConvert.SerializeObject(expectedResponse), JsonConvert.SerializeObject(resultContent));
}
public void postInitialProcessDocument_controller_method_end_to_end_test_with_a_conflict_exception_in_the_gateway() //testing exception handling. in this case testing how our custom exception bubbles up from gateway. chose conflict exception to test 2 things at once - exception handling + custom exception wrapping.
{
//arrange
string conflictGuid = _faker.Random.Guid().ToString(); //This is the conflicting Guid, that will be repeated accross 2 request objects.
PostInitialProcessDocumentRequest requestObject1 = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
requestObject1.processRef = conflictGuid; // set conflict Guid.
_processDataController.PostInitialProcessDocument(requestObject1); //The process document with conflict Guid identifier has been inserted into the database.
PostInitialProcessDocumentRequest requestObject2 = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
requestObject2.processRef = conflictGuid; // set conflict Guid.
//act
var controllerResponse = _processDataController.PostInitialProcessDocument(requestObject2); //The attempt to insert another document into the database with the already existing identifier (conflict guid). Conflict happens.
var actualResult = (ObjectResult)controllerResponse;
var errorMessage = (string)actualResult.Value;
//assert
Assert.NotNull(controllerResponse);
Assert.IsInstanceOf <ConflictObjectResult>(actualResult);
Assert.NotNull(actualResult);
Assert.IsInstanceOf <string>(errorMessage);
Assert.NotNull(errorMessage);
Assert.IsNotEmpty(errorMessage);
Assert.AreEqual(409, actualResult.StatusCode);
Assert.AreNotEqual("An error inserting an object with duplicate key has occured - ", errorMessage); //If they're equal, then it means that empty exception has been appended to this sentense.
//There is no good way to check the error message, since it would require to cause the exception manually through writing error handling implementation in the test.
}
public IActionResult PostInitialProcessDocument([FromBody] PostInitialProcessDocumentRequest request)
{
//validate request
var isRequestValid = _postValidator.Validate(request);
if (isRequestValid.IsValid)
{
try
{
PostInitialProcessDocumentResponse usecaseResponse = _processDataUsecase.ExecutePost(request);
return(StatusCode(201, usecaseResponse));
}
catch (ConflictException ex)
{
return(Conflict("An error inserting an object with duplicate key has occured - " +
ex.InnerException));
}
catch (Exception ex)
{
return(StatusCode(500, "An error has occurred - " + ex.InnerException));
}
}
return(BadRequest(isRequestValid.Errors));
}
public void postInitialProcessDocument_controller_method_end_to_end_test_with_a_invalid_request() //testing, when validation fails
{
//arrange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
string nonsenseGuid = _faker.Random.Word().ToString(); // invalid Guid (not even a guid) - this should trip the validation.
requestObject.processRef = nonsenseGuid;
var postValidator = new PostInitialProcessDocumentRequestValidator();
var isRequestValid = postValidator.Validate(requestObject);
var errors = isRequestValid.Errors;
var expectedResponse = new BadRequestObjectResult(errors);
//act
var controllerResponse = _processDataController.PostInitialProcessDocument(requestObject);
var actualResult = (ObjectResult)controllerResponse;
var actualContents = (IList <ValidationFailure>)actualResult.Value;
//assert
Assert.NotNull(controllerResponse);
Assert.IsInstanceOf <BadRequestObjectResult>(actualResult); // should be bad request, since validation fails.
Assert.NotNull(actualResult);
Assert.IsInstanceOf <IList <ValidationFailure> >(actualContents);
Assert.NotNull(actualContents);
Assert.AreEqual(1, actualContents.Count); // there should be 1 validation failure coming from the invalid guid
Assert.AreEqual(400, actualResult.StatusCode); // expecting bad request result
//the following simply proves that validation errors get wraped up properly.
Assert.AreEqual(((IList <ValidationFailure>)expectedResponse.Value)[0].ErrorMessage, actualContents[0].ErrorMessage);
}
public void postInitialProcessDocument_controller_method_end_to_end_test_with_a_valid_request() //testing regular response
{
//arrange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
var expectedResponse = new PostInitialProcessDocumentResponse(requestObject, requestObject.processRef, DateTime.Now);
//act
var controllerResponse = _processDataController.PostInitialProcessDocument(requestObject);
var result = (ObjectResult)controllerResponse;
var resultContent = (PostInitialProcessDocumentResponse)result.Value;
//assert
//check if the doc got inserted
var documentFromDB = BsonSerializer.Deserialize <MatProcessData>(_dbcontext.getCollection().FindAsync(Builders <BsonDocument> .Filter.Eq("_id", requestObject.processRef)).Result.FirstOrDefault());
Assert.NotNull(documentFromDB);
Assert.AreEqual(requestObject.processRef, documentFromDB.Id);
Assert.NotNull(documentFromDB.ProcessType);
Assert.AreEqual(requestObject.processType.value, documentFromDB.ProcessType.value);
Assert.AreEqual(requestObject.processType.name, documentFromDB.ProcessType.name);
Assert.AreEqual(requestObject.processDataSchemaVersion, documentFromDB.ProcessDataSchemaVersion);
//check the controller response
Assert.NotNull(controllerResponse);
Assert.IsInstanceOf <ObjectResult>(result);
Assert.NotNull(result);
Assert.IsInstanceOf <PostInitialProcessDocumentResponse>(result.Value);
Assert.NotNull(result.Value);
Assert.AreEqual(expectedResponse.ProcessRef, resultContent.ProcessRef);
Assert.AreEqual(expectedResponse.Request.processRef, resultContent.Request.processRef);
//check status code
Assert.AreEqual(201, result.StatusCode);
}
public void given_postInitialProcessDocumentRequest_object_when_createProcessDataObject_factory_method_is_called_it_returns_correctly_populated_processData_domain_object()
{
//arrange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
//act
var domainObject = ProcessDataFactory.CreateProcessDataObject(requestObject);
//assert
Assert.NotNull(domainObject);
Assert.IsInstanceOf <MatProcessData>(domainObject);
Assert.AreEqual(requestObject.processRef, domainObject.Id);
Assert.AreEqual(requestObject.processType.value, domainObject.ProcessType.value);
Assert.AreEqual(requestObject.processType.name, domainObject.ProcessType.name);
Assert.NotNull(domainObject.DateCreated);
Assert.NotNull(domainObject.DateLastModified);
Assert.AreEqual(domainObject.DateCreated, domainObject.DateLastModified); //DateLastModified should be equal to the date of creation because the test is for an object that is created now.
Assert.AreEqual(DateTime.MinValue, domainObject.DateCompleted);
Assert.False(domainObject.ProcessDataAvailable);
Assert.AreEqual(requestObject.processDataSchemaVersion, domainObject.ProcessDataSchemaVersion);
Assert.AreEqual("Not completed", domainObject.ProcessStage); //it's not confirmed yet whether it's going to be int or string
Assert.Null(domainObject.LinkedProcessId);
// Assert.AreEqual(new { }, domainObject.PreProcessData); //Causes error --> Expected: <{ }> (<>f__AnonymousType0); But was: <{ }> (<> f__AnonymousType0)
Assert.AreEqual(0, domainObject.PreProcessData.GetType().GetProperties().Count()); // using reflections, because the above won't work
Assert.AreEqual(0, domainObject.ProcessData.GetType().GetProperties().Count());
Assert.AreEqual(0, domainObject.PostProcessData.GetType().GetProperties().Count());
}
public PostInitialProcessDocumentResponse ExecutePost(PostInitialProcessDocumentRequest request)
{
MatProcessData mappedRequest = ProcessDataFactory.CreateProcessDataObject(request); //mapping request into to be inserted domain object
string gatewayResponse = _processDataGateway.PostInitialProcessDocument(mappedRequest);
return(new PostInitialProcessDocumentResponse(request, gatewayResponse, DateTime.Now));
}
public void given_a_postInitialProcessRequest_object_with_processType_object_that_is_set_to_null_value_when_validator_is_called_it_returns_an_error()
{
var request = new PostInitialProcessDocumentRequest()
{
processType = null
};
_postInitProcessDocValidator.ShouldHaveValidationErrorFor(r => r.processType, request).WithErrorMessage("Process type must be provided.");
}
public void given_a_postInitialProcessRequest_object_with_processDataSchemaVersion_that_is_set_to_zero_or_null_value_when_validator_is_called_it_returns_an_error(int processDataSchemaVersion)
{
var request = new PostInitialProcessDocumentRequest()
{
processDataSchemaVersion = processDataSchemaVersion
};
_postInitProcessDocValidator.ShouldHaveValidationErrorFor(r => r.processDataSchemaVersion, request).WithErrorMessage("Process data schema version must be provided.");
}
public void given_a_postInitialProcessRequest_object_with_processRef_that_is_set_to_a_whitespace_or_null_or_empty_value_when_validator_is_called_it_returns_an_error(string processReference)
{
var request = new PostInitialProcessDocumentRequest()
{
processRef = processReference
};
_postInitProcessDocValidator.ShouldHaveValidationErrorFor(r => r.processRef, request).WithErrorMessage("Process reference must be provided.");
}
[TestCase("ju5t50m3-w0rd-th4t-w1ll-m34nn0th1ng7")] //uses characters that are not among hexadecimal numerals
public void given_a_postInitialProcessRequest_object_with_an_invalid_processRef_when_validator_is_called_it_returns_an_error(string processReference)
{
var request = new PostInitialProcessDocumentRequest()
{
processRef = processReference
};
_postInitProcessDocValidator.ShouldHaveValidationErrorFor(r => r.processRef, request);
}
public void given_a_postInitialProcessRequest_object_with_a_valid_processRef_when_validator_is_called_it_does_NOT_return_an_error()
{
var request = new PostInitialProcessDocumentRequest()
{
processRef = randomGuid
};
_postInitProcessDocValidator.ShouldNotHaveValidationErrorFor(r => r.processRef, request);
}
public void given_a_postInitialProcessRequest_object_with_processType_object_whos_name_field_is_set_to_a_whitespace_or_null_or_empty_value_when_validator_is_called_it_returns_an_error(string processTypeName)
{
var request = new PostInitialProcessDocumentRequest()
{
processType = new ProcessType()
{
name = processTypeName
}
};
_postInitProcessDocValidator.ShouldHaveValidationErrorFor(r => r.processType.name, request).WithErrorMessage("Process type name must be provided.");
}
public void given_a_postInitialProcessDocumentRequest_when_postInitialProcessDocument_controller_method_is_called_it_then_calls_the_use_case_while_passing_the_request_object_to_it()
{
//arrange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
_mockValidatorPost.Setup(v => v.Validate(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(new FV.ValidationResult()); //set up mock validation to return Validation with no errors.
_mockUsecase.Setup(g => g.ExecutePost(It.IsAny <PostInitialProcessDocumentRequest>()));
//act
_processDataController.PostInitialProcessDocument(requestObject);
//assert
_mockUsecase.Verify(x => x.ExecutePost(
It.Is <PostInitialProcessDocumentRequest>(req => req.processRef == requestObject.processRef)
), Times.Once);
}
public void given_a_valid_request_when_postinitialprocessdocument_controller_method_is_called_then_it_returns_a_response_that_resource_was_created() //temporary test until actual implementation will be worked on.
{
//arrange
int expectedStatusCode = 201;
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
_mockValidatorPost.Setup(v => v.Validate(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(new FV.ValidationResult()); //set up mock validation to return Validation with no errors.
//act
IActionResult controllerResponse = _processDataController.PostInitialProcessDocument(requestObject);
var result = (ObjectResult)controllerResponse;
var actualStatusCode = result.StatusCode;
//assert
Assert.NotNull(controllerResponse);
Assert.NotNull(result);
Assert.AreEqual(expectedStatusCode, actualStatusCode);
}
public void given_a_request_when_postInitialProcessDocument_controller_method_is_called_then_it_calls_the_validator_with_that_request()
{
//arrange
PostInitialProcessDocumentRequest request = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
_mockValidatorPost.Setup(v => v.Validate(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(new FV.ValidationResult()); //set up mock validation to return Validation with no errors.
_mockUsecase.Setup(g => g.ExecutePost(It.IsAny <PostInitialProcessDocumentRequest>()));
//act
_processDataController.PostInitialProcessDocument(request);
//assert
_mockValidatorPost.Verify(v => v.Validate(It.Is <PostInitialProcessDocumentRequest>(i =>
i.processRef == request.processRef &&
i.processType.name == request.processType.name &&
i.processType.value == request.processType.value &&
i.processDataSchemaVersion == request.processDataSchemaVersion
)), Times.Once);
}
public static MatProcessData CreateProcessDataObject(PostInitialProcessDocumentRequest requestObject) //Maps PostInitialDocumentRequest object to ProcessData domain object
{
DateTime dateOfCreation = DateTime.Now; // need this here because DateCreated and DateLastModified have to be equal
return(new MatProcessData()
{
Id = requestObject.processRef,
ProcessType = requestObject.processType,
DateCreated = dateOfCreation,
DateLastModified = dateOfCreation,
DateCompleted = DateTime.MinValue,
ProcessDataAvailable = false,
ProcessDataSchemaVersion = requestObject.processDataSchemaVersion,
ProcessStage = "Not completed",
LinkedProcessId = null,
PreProcessData = new { },
ProcessData = new { },
PostProcessData = new { }
});
}
public void given_the_requestObject_when_executePost_usecase_method_is_called_then_the_gateway_is_called_with_factory_output() // this should be 2 tests really, one to see if factory gets called, and the other to see if gateway is called, but due to using static factory method this becomes impossible to separate.
{
//arrange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
MatProcessData domainObject = ProcessDataFactory.CreateProcessDataObject(requestObject);
mockMatGateway.Setup(g => g.PostInitialProcessDocument(It.IsAny <MatProcessData>())).Returns((MatProcessData dobj) => dobj.Id);
//act
processDataUseCase.ExecutePost(requestObject);
//assert
mockMatGateway.Verify(g => g.PostInitialProcessDocument(It.Is <MatProcessData>(d =>
d.ProcessType.name == requestObject.processType.name && //checking whether properties that have to be transfered from request object to domain object are present
d.Id == requestObject.processRef &&
d.ProcessType.value == requestObject.processType.value &&
d.ProcessDataSchemaVersion == requestObject.processDataSchemaVersion &&
d.DateCompleted == DateTime.MinValue && //checking whether some of the properties that factory has to generate itself are present.
d.ProcessStage == "Not completed"
)), Times.Once);
// This checks whether the usecase calls the gateway with the output of the factory method.
}
public void given_the_requestObject_when_executePost_usecase_method_is_called_then_it_wraps_gateway_output_into_postInitialDocumentResponse_object()
{
//arrange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
MatProcessData domainObject = ProcessDataFactory.CreateProcessDataObject(requestObject);
mockMatGateway.Setup(g => g.PostInitialProcessDocument(It.IsAny <MatProcessData>())).Returns((MatProcessData dobj) => dobj.Id);
//act
var usecaseResponse = processDataUseCase.ExecutePost(requestObject);
//assert
Assert.IsInstanceOf <PostInitialProcessDocumentResponse>(usecaseResponse);
Assert.IsInstanceOf <PostInitialProcessDocumentRequest>(usecaseResponse.Request);
Assert.IsInstanceOf <string>(usecaseResponse.ProcessRef);
Assert.IsInstanceOf <DateTime>(usecaseResponse.GeneratedAt);
Assert.AreEqual(requestObject.processRef, usecaseResponse.Request.processRef);
Assert.AreEqual(requestObject.processRef, usecaseResponse.ProcessRef);
Assert.NotNull(usecaseResponse.GeneratedAt);
Assert.AreNotEqual(DateTime.MinValue, usecaseResponse.GeneratedAt);
}
public void given_request_with_unique_key_that_already_exists_when_postInitialProcessDocument_controller_method_is_called_then_upon_catching_custom_conflict_exception_the_correct_conflict_result_is_returned() //testing exception handling. in this case testing how our custom exception bubbles up from gateway. chose conflict exception to test 2 things at once - exception handling + custom exception wrapping.
{
//arrange
//setup mocks:
_mockValidatorPost.Setup(v => v.Validate(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(new FV.ValidationResult()); //set up mock validation to return Validation with no errors.
_mockUsecase.Setup(g => g.ExecutePost(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(() => throw new ConflictException(faker.Random.Word(), new Exception(faker.Random.Word())));
//setup double insert:
string conflictGuid = faker.Random.Guid().ToString(); //This is the conflicting Guid, that will be repeated accross 2 request objects.
PostInitialProcessDocumentRequest requestObject1 = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
requestObject1.processRef = conflictGuid; // set conflict Guid.
_processDataController.PostInitialProcessDocument(requestObject1); //The process document with conflict Guid identifier has been inserted into the database.
PostInitialProcessDocumentRequest requestObject2 = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
requestObject2.processRef = conflictGuid; // set conflict Guid.
//act
var controllerResponse = _processDataController.PostInitialProcessDocument(requestObject2); //The attempt to insert another document into the database with the already existing identifier (conflict guid). Conflict happens.
var actualResult = (ObjectResult)controllerResponse;
var errorMessage = (string)actualResult.Value;
//assert
Assert.NotNull(controllerResponse);
Assert.IsInstanceOf <ConflictObjectResult>(actualResult);
Assert.NotNull(actualResult);
Assert.IsInstanceOf <string>(errorMessage);
Assert.NotNull(errorMessage);
Assert.IsNotEmpty(errorMessage);
Assert.AreEqual(409, actualResult.StatusCode);
Assert.AreNotEqual("An error inserting an object with duplicate key has occured - ", errorMessage); //If they're equal, then it means that empty exception has been appended to this sentense.
//There is no good way to check the error message, since it would require to cause the exception manually through writing error handling implementation in the test.
}
