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. }