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_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 given_a_request_when_ProcessImageUseCase_ExecuteGet_method_is_called_then_it_returns_the_response_object_of_correct_type_and_data() { //assert var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); var imageKey = ImagePersistingHelper.generateImageKey(request.processType, request.imageId, request.processRef, request.fileExtension); var expectedBase64ImageString = MatProcessDataHelper.CreatePostProcessImageRequestObject().base64Image; _mockGateway.Setup(g => g.RetrieveImage(It.Is <string>(obj => obj == imageKey))).Returns(expectedBase64ImageString); var expectedUsecaseResponse = new GetProcessImageResponse(expectedBase64ImageString, DateTime.Now, request); //The date time is impossible to test equality for, as it will differ in few microseconds from the actual response one. So I set it to DateTime.Min to signify its unimportance. //act var usecaseResponse = _processImageUseCase.ExecuteGet(request); //assert Assert.IsNotNull(usecaseResponse); Assert.IsInstanceOf <GetProcessImageResponse>(usecaseResponse); Assert.AreEqual(expectedUsecaseResponse.Base64Image, usecaseResponse.Base64Image); Assert.AreEqual(expectedUsecaseResponse.Request.processRef, usecaseResponse.Request.processRef); Assert.AreEqual(expectedUsecaseResponse.Request.imageId, usecaseResponse.Request.imageId); //This assertion has an accuracy of 1 second. If time difference between [when expected object was created] and [when actual usecase response was created] is within 1 second, then the times are considered equal. 1 Second is plenty of time for the code in between to run, considering it's using a Mock gateway. Assert.Less((usecaseResponse.GeneratedAt - expectedUsecaseResponse.GeneratedAt).TotalMilliseconds, 1000); }
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 void given_successful_request_validation_when_GetProcessImage_controller_method_is_called_then_it_returns_an_Ok_result_with_correct_data_based_of_that_request() { //arrange var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); var expectedResponse = new GetProcessImageResponse(_faker.Random.Hash().ToString(), DateTime.Now, request); _mockUsecase.Setup(u => u.ExecuteGet(It.IsAny <GetProcessImageRequest>())).Returns(expectedResponse); _mockGetValidator.Setup(x => x.Validate(It.IsAny <GetProcessImageRequest>())).Returns(new FV.ValidationResult()); //setup validator to return a no error validation result //act var controllerResponse = _processImageController.GetProcessImage(request); var result = controllerResponse as ObjectResult; var resultContents = result.Value as GetProcessImageResponse; //assert Assert.NotNull(controllerResponse); Assert.IsInstanceOf <OkObjectResult>(result); Assert.NotNull(result); Assert.IsInstanceOf <GetProcessImageResponse>(resultContents); Assert.NotNull(resultContents); Assert.AreEqual(expectedResponse.Base64Image, resultContents.Base64Image); Assert.AreEqual(expectedResponse.GeneratedAt, resultContents.GeneratedAt); Assert.AreEqual(expectedResponse.Request.processRef, resultContents.Request.processRef); Assert.AreEqual(expectedResponse.Request.imageId, resultContents.Request.imageId); }
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_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 void context_can_get_process_data() { //arrange MatProcessData processData = MatProcessDataHelper.CreateProcessDataObject(); var bsonObject = BsonDocument.Parse(JsonConvert.SerializeObject(processData)); collection.InsertOne(bsonObject); //act var context = new MatDbContext(mockOptions.Object); var filter = Builders <BsonDocument> .Filter.Eq("_id", processData.Id); var result = context.getCollection().FindAsync(filter).Result.FirstOrDefault(); var resultDesirialzie = BsonSerializer.Deserialize <MatProcessData>(result); //assert Assert.AreEqual(processData.Id, resultDesirialzie.Id); Assert.AreEqual(processData.ProcessType.value, resultDesirialzie.ProcessType.value); Assert.AreEqual(processData.ProcessType.name, resultDesirialzie.ProcessType.name); Assert.AreEqual(processData.DateCreated, resultDesirialzie.DateCreated); Assert.AreEqual(processData.DateLastModified, resultDesirialzie.DateLastModified); Assert.AreEqual(processData.DateCompleted, resultDesirialzie.DateCompleted); Assert.AreEqual(processData.ProcessDataAvailable, resultDesirialzie.ProcessDataAvailable); Assert.AreEqual(processData.ProcessDataSchemaVersion, resultDesirialzie.ProcessDataSchemaVersion); Assert.AreEqual(processData.ProcessStage, resultDesirialzie.ProcessStage); Assert.AreEqual(processData.LinkedProcessId, resultDesirialzie.LinkedProcessId); Assert.AreEqual(processData.PreProcessData, resultDesirialzie.PreProcessData); Assert.AreEqual(processData.ProcessData, resultDesirialzie.ProcessData); Assert.AreEqual(processData.PostProcessData, resultDesirialzie.PostProcessData); }
public void given_failed_request_validation_when_GetProcessImage_controller_method_is_called_then_it_makes_the_logger_log_the_correctly_formatted_validation_failure_messages_returned_by_the_validator() { //arrange var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); //doesn't matter that it's valid right now, because validation failure is built up manually anyway. This object is needs values set so that logger message could be checked. int errorCount = _faker.Random.Int(1, 10); //simulate from 1 to 10 validation errors (triangulation). var validationErrorList = new List <ValidationFailure>(); //this list will be used as constructor argument for 'ValidationResult'. for (int i = errorCount; i > 0; i--) { validationErrorList.Add(new ValidationFailure(_faker.Random.Word(), _faker.Random.Word())); } //generate from 1 to 10 fake validation errors. Single line for-loop so that it wouldn't distract from what's key in this test. var fakeValidationResult = new FV.ValidationResult(validationErrorList); //Need to create ValidationResult so that I could setup Validator mock to return it upon '.Validate()' call. Also this is the only place where it's possible to manipulate the validation result - You can only make the validation result invalid by inserting a list of validation errors as a parameter through a constructor. The boolean '.IsValid' comes from expression 'IsValid => Errors.Count == 0;', so it can't be set manually. _mockGetValidator.Setup(v => v.Validate(It.IsAny <GetProcessImageRequest>())).Returns(fakeValidationResult); string expectedValidationErrorMessages = fakeValidationResult.Errors .Select(e => $"Validation error for: '{e.PropertyName}', message: '{e.ErrorMessage}'.") .Aggregate((acc, m) => acc + "\n" + m); string expectedLogMessage = $"Get ProcessImage request for Process Type: {request.processType}, Process Reference: {request.processRef}, Image Id: {request.imageId} and File Extension: {request.fileExtension} did not pass the validation:\n\n{expectedValidationErrorMessages}"; //act _processImageController.GetProcessImage(request); //assert _mockLogger.Verify(l => l.Log( LogLevel.Information, It.IsAny <EventId>(), It.Is <FormattedLogValues>(v => v.ToString().Contains(expectedLogMessage)), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >() ), Times.Once); }
public void update_process_controller_end_to_end_test(string processRef) { //arrange var dataToInsert = MatProcessDataHelper.CreateProcessDataObject(); dataToInsert.Id = processRef; _dbcontext.getCollection().InsertOne(BsonDocument.Parse(JsonConvert.SerializeObject(dataToInsert))); //fields to update var dataToUpdate = new MatUpdateProcessData(); dataToUpdate.DateLastModified = DateTime.Now; dataToUpdate.PreProcessData = new { randomField = "abc" }; var request = new UpdateProcessDataRequest() { processRef = processRef, processDataToUpdate = dataToUpdate }; //act var response = _processDataController.UpdateExistingProcessDocument(request); var okResult = (OkObjectResult)response; var updateProcessDataResponse = okResult.Value as UpdateProcessDataResponse; //assert Assert.IsInstanceOf <MatProcessData>(updateProcessDataResponse.UpdatedProcessData); Assert.AreEqual(processRef, updateProcessDataResponse.UpdatedProcessData.Id); Assert.AreEqual(dataToUpdate.DateLastModified.ToShortDateString(), updateProcessDataResponse.UpdatedProcessData.DateLastModified.ToShortDateString()); Assert.AreEqual(JsonConvert.SerializeObject(dataToUpdate.PreProcessData), JsonConvert.SerializeObject(updateProcessDataResponse.UpdatedProcessData.PreProcessData)); }
public void test_that_object_can_be_successfully_updated() { //arrange MatProcessData processData = MatProcessDataHelper.CreateProcessDataObject(); var bsonObject = BsonDocument.Parse(JsonConvert.SerializeObject(processData)); collection.InsertOne(bsonObject); //object to update var objectToUpdate = new MatUpdateProcessData(); var processRef = processData.Id; objectToUpdate.DateLastModified = _faker.Date.Recent(); objectToUpdate.ProcessData = new { firstField = _faker.Random.Word(), anyField = _faker.Random.Words(), numberField = _faker.Random.Number() }; //get update definition var updateDefinition = UpdateProcessDocumentHelper.PrepareFieldsToBeUpdated(objectToUpdate); //act var result = processDataGateway.UpdateProcessData(updateDefinition, processRef); //assert Assert.AreEqual(processRef, result.Id); Assert.AreEqual(JsonConvert.SerializeObject(objectToUpdate.ProcessData), JsonConvert.SerializeObject(result.ProcessData)); Assert.AreEqual(objectToUpdate.DateLastModified.ToShortDateString(), result.DateLastModified.ToShortDateString()); Assert.IsInstanceOf <MatProcessData>(result); }
public void test_that_gateway_return_object_matches_object_in_database() { //arrange MatProcessData processData = MatProcessDataHelper.CreateProcessDataObject(); var bsonObject = BsonDocument.Parse(JsonConvert.SerializeObject(processData)); collection.InsertOne(bsonObject); //act var result = processDataGateway.GetProcessData(processData.Id); //assert Assert.AreEqual(processData.Id, result.Id); Assert.AreEqual(processData.ProcessType.value, result.ProcessType.value); Assert.AreEqual(processData.ProcessType.name, result.ProcessType.name); Assert.AreEqual(processData.DateCreated, result.DateCreated); Assert.AreEqual(processData.DateLastModified, result.DateLastModified); Assert.AreEqual(processData.DateCompleted, result.DateCompleted); Assert.AreEqual(processData.ProcessDataAvailable, result.ProcessDataAvailable); Assert.AreEqual(processData.ProcessDataSchemaVersion, result.ProcessDataSchemaVersion); Assert.AreEqual(processData.ProcessStage, result.ProcessStage); Assert.AreEqual(processData.LinkedProcessId, result.LinkedProcessId); Assert.AreEqual(processData.PreProcessData, result.PreProcessData); Assert.AreEqual(processData.ProcessData, result.ProcessData); Assert.AreEqual(processData.PostProcessData, result.PostProcessData); Assert.IsInstanceOf <MatProcessData>(result); }
public void given_a_request_with_valid_ImageId_guid_when_getProcessImageRequestValidator_is_called_then_it_returns_no_error() { //arange var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); //act, assert _getValidator.ShouldNotHaveValidationErrorFor(req => req.imageId, request); }
public void given_a_request_with_valid_base64Image_string_when_postProcessImageRequestValidator_is_called_then_it_returns_no_error() { //arange var request = MatProcessDataHelper.CreatePostProcessImageRequestObject(); //act, assert _postValidator.ShouldNotHaveValidationErrorFor(req => req.base64Image, request); }
public void given_a_request_with_null_empty_or_whitespace_processRef_when_postProcessImageRequestValidator_is_called_then_it_returns_an_error(string processRef) { //arrange var request = MatProcessDataHelper.CreatePostProcessImageRequestObject(); request.processRef = processRef; //act, assert _postValidator.ShouldHaveValidationErrorFor(req => req.processRef, request).WithErrorMessage("Process reference must be provided."); }
public void given_a_request_with_empty_or_whitespace_imageId_when_getProcessImageRequestValidator_is_called_then_it_returns_an_error(string imageId) { //arrange var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); request.imageId = imageId; //act, assert _getValidator.ShouldHaveValidationErrorFor(req => req.imageId, request).WithErrorMessage("Image Id must not be empty."); }
[TestCase("ju5t70m3-w0rd-th4t-w1ll-m34nn0th1ng0")] //uses characters that are not among hexadecimal numerals public void given_a_request_with_invalid_ImageId_guid_when_postProcessImageRequestValidator_is_called_then_it_returns_an_error(string imageId) { //arrange var request = MatProcessDataHelper.CreatePostProcessImageRequestObject(); request.imageId = imageId; //act, assert _postValidator.ShouldHaveValidationErrorFor(req => req.imageId, request).WithErrorMessage("You need to provide a valid Image Id."); }
public void given_a_request_with_null_empty_or_whitespace_base64Image_string_when_postProcessImageRequestValidator_is_called_then_it_returns_an_error(string base64Image) { //arrange var request = MatProcessDataHelper.CreatePostProcessImageRequestObject(); request.base64Image = base64Image; //act, assert _postValidator.ShouldHaveValidationErrorFor(req => req.base64Image, request).WithErrorMessage("Base64 Image string must be provided."); }
[TestCase("data:image/zz;base64,/1j/7TTQSkZJRgACAQEASBBI/2wBDAAgG\\BgcGBQgHwcJCQg")] //file extension in the data bit is less than 3 chars long public void given_a_request_with_an_invalid_base64Image_string_when_postProcessImageRequestValidator_is_called_then_it_returns_an_error(string base64Image) { //arrange var request = MatProcessDataHelper.CreatePostProcessImageRequestObject(); request.base64Image = base64Image; //act, assert _postValidator.ShouldHaveValidationErrorFor(req => req.base64Image, request).WithErrorMessage("You need to provide a valid Base64 Image string."); }
public void given_the_double_insert_of_matProcessData_domain_object_when_postInitialProcessDocument_gateway_method_is_called_then_conflict_exception_is_thrown() { //arrange MatProcessData domainObject = ProcessDataFactory.CreateProcessDataObject(MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject()); //act string response_Id = processDataGateway.PostInitialProcessDocument(domainObject); //first insert. Assert.Throws <ConflictException>(() => processDataGateway.PostInitialProcessDocument(domainObject)); //the second document insertion happends, while asserting. }
[TestCase("ju5t50m3-w0rd-th4t-w1ll-m34nn0th1ng0")] //uses characters that are not among hexadecimal numerals public void given_a_request_with_invalid_processRef_guid_when_getProcessImageRequestValidator_is_called_then_it_returns_an_error(string processRef) { //arrange var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); request.processRef = processRef; //act, assert _getValidator.ShouldHaveValidationErrorFor(req => req.processRef, request).WithErrorMessage("You need to provide a valid process reference."); }
public void given_a_request_with_null_fileExtension_when_getProcessImageRequestValidator_is_called_then_it_returns_an_error() { //arrange var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); request.fileExtension = null; //act, assert _getValidator.ShouldHaveValidationErrorFor(req => req.fileExtension, request).WithErrorMessage("File Extension must be provided."); }
public void given_the_matProcessData_domain_object_when_postInitialProcessDocument_gateway_method_is_called_then_it_returns_id_of_the_inserted_document() { //arrange MatProcessData domainObject = ProcessDataFactory.CreateProcessDataObject(MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject()); //act string response_Id = processDataGateway.PostInitialProcessDocument(domainObject); //assert Assert.AreEqual(domainObject.Id, response_Id); }
public void given_a_request_when_ProcessImageUseCase_ExecuteGet_method_is_called_then_it_calls_the_gateway_with_imageKey_generated_based_on_the_request() { //assert var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); var imageKey = ImagePersistingHelper.generateImageKey(request.processType, request.imageId, request.processRef, request.fileExtension); //act _processImageUseCase.ExecuteGet(request); //assert _mockGateway.Verify(g => g.RetrieveImage(It.Is <string>(obj => obj == imageKey)), Times.Once); }
public void given_a_request_object_when_GetProcessImage_controller_method_is_called_then_it_calls_the_validator_with_that_request_object() { //arrange var request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); _mockGetValidator.Setup(x => x.Validate(It.IsAny <GetProcessImageRequest>())).Returns(new FV.ValidationResult()); //setup validator to return a no error validation result //act _processImageController.GetProcessImage(request); //assert _mockGetValidator.Verify(v => v.Validate(It.Is <GetProcessImageRequest>(obj => obj == request)), Times.Once); }
public void given_a_request_when_ProcessImageUseCase_ExecutePost_method_is_called_then_it_calls_the_ProcessImageDecoder_with_imageString_from_request() { //arrange var request = MatProcessDataHelper.CreatePostProcessImageRequestObject(); _mockImageDecoder.Setup(x => x.DecodeBase64ImageString(request.base64Image)).Returns(new Base64DecodedData() { imageExtension = _faker.Random.Word() }); //act _processImageUseCase.ExecutePost(request); //assert _mockImageDecoder.Verify(d => d.DecodeBase64ImageString(It.Is <string>(s => s == request.base64Image)), Times.Once); }
public void when_ProcessImageUseCase_ExecutePost_method_is_called_then_it_calls_the_gateway() { //arrange var request = MatProcessDataHelper.CreatePostProcessImageRequestObject(); _mockImageDecoder.Setup(x => x.DecodeBase64ImageString(request.base64Image)).Returns(new Base64DecodedData() { imageExtension = _faker.Random.Word() }); //act _processImageUseCase.ExecutePost(request); //assert _mockGateway.Verify(g => g.UploadImage(It.IsAny <ProcessImageData>()), Times.Once); }
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_the_matProcessData_domain_object_when_postInitialProcessDocument_gateway_method_is_called_then_the_parsed_object_gets_added_into_the_database() { //arrange MatProcessData domainObject = ProcessDataFactory.CreateProcessDataObject(MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject()); //act processDataGateway.PostInitialProcessDocument(domainObject); //assert var documentFromDB = BsonSerializer.Deserialize <MatProcessData>(collection.FindAsync(Builders <BsonDocument> .Filter.Eq("_id", domainObject.Id)).Result.FirstOrDefault()); Assert.AreEqual(domainObject.Id, documentFromDB.Id); Assert.AreEqual(domainObject.ProcessType.value, documentFromDB.ProcessType.value); Assert.AreEqual(domainObject.ProcessType.name, documentFromDB.ProcessType.name); Assert.AreEqual(domainObject.ProcessDataSchemaVersion, documentFromDB.ProcessDataSchemaVersion); }
public void given_successful_request_validation_when_GetProcessImage_controller_method_is_called_then_it_calls_usecase_with_correct_data_based_of_request() { //arrange GetProcessImageRequest request = MatProcessDataHelper.CreateGetProcessImageRequestObject(); _mockGetValidator.Setup(x => x.Validate(It.IsAny <GetProcessImageRequest>())).Returns(new FV.ValidationResult()); //setup validator to return a no error validation result //act _processImageController.GetProcessImage(request); //assert _mockUsecase.Verify(u => u.ExecuteGet(It.Is <GetProcessImageRequest>(obj => obj.processRef == request.processRef && obj.imageId == request.imageId )), Times.Once); }