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);
}
