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 string PostInitialProcessDocument(MatProcessData processDoc)
{
try
{
BsonDocument bsonObject = BsonDocument.Parse(JsonConvert.SerializeObject(processDoc));
matDbContext.getCollection().InsertOneAsync(bsonObject).Wait();
return(processDoc.Id);
}
catch (AggregateException ex) //AggregateException - it can wraps up other exceptions while async action is happening. In this case it wraps up the MongoWriteException, which we need to catch. However due to it being wrapped, we can't really catch it...unless you handle the aggregate exception, and extract the Mongo exception. That's what's happening here.
{
ex.Handle((x) =>
{
if (x is MongoWriteException)
{
throw new ConflictException(ex.Message, ex.InnerException); //throw our custom exception, with the information we need wrapped up.
}
throw ex;
});
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
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_the_matProcessData_domain_object_when_postInitialProcessDocument_gateway_method_is_called_then_the_number_of_documents_in_the_database_increases_by_one() //test that checks whether the db doesn't get cleared or overwritten somehow upon insertion
{
//arrange
var unclearedDocumentCount = collection.CountDocuments(Builders <BsonDocument> .Filter.Empty); //did some testing around this, seems like the database doesn't get cleared after every test. Depending on the ordering, it might not actually be empty at the start of this test. When this is unaccounted for, it makes this test fail.
//pre-insert between 0 and 7 documents into database, so that it wouldn't be necessarily empty (triangulation)
int preInsertedDocumentCount = _faker.Random.Int(0, 7);
for (int i = preInsertedDocumentCount; i > 0; i--)
{
MatProcessData preInsertedDomainObject = ProcessDataFactory.CreateProcessDataObject(MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject());
collection.InsertOne(BsonDocument.Parse(JsonConvert.SerializeObject(preInsertedDomainObject)));
}
//a new object that will be inserted upon gateway call
MatProcessData toBeInsertedDomainObject = ProcessDataFactory.CreateProcessDataObject(MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject());
//act
processDataGateway.PostInitialProcessDocument(toBeInsertedDomainObject);
//assert
var startingDocumentCount = unclearedDocumentCount + preInsertedDocumentCount;
Assert.AreEqual(startingDocumentCount + 1, collection.CountDocuments(Builders <BsonDocument> .Filter.Empty));
}
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 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_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.
}
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 check_gateway_returns_expected_response()
{
//arrange
string processRef = faker.Random.Guid().ToString();
var request = new GetProcessDataRequest {
processRef = processRef
};
var response = new MatProcessData();
//act
mockMatGateway.Setup(x => x.GetProcessData(processRef)).Returns(response);
var result = processDataUseCase.ExecuteGet(request);
//assert
Assert.AreEqual(response, result.ProcessData);
}
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 can_create_mat_process_data_object_from_empty_object()
{
//arrange
var matProcessData = new MatProcessData();
//act
var processDataFromFactory = ProcessDataFactory.CreateProcessDataObject(BsonDocument.Parse(JsonConvert.SerializeObject(matProcessData)));
//assert
Assert.AreEqual(matProcessData.ProcessDataSchemaVersion, processDataFromFactory.ProcessDataSchemaVersion);
Assert.AreEqual(matProcessData.DateCompleted, processDataFromFactory.DateCompleted);
Assert.AreEqual(matProcessData.DateCreated, processDataFromFactory.DateCreated);
Assert.AreEqual(matProcessData.DateLastModified, processDataFromFactory.DateLastModified);
Assert.AreEqual(matProcessData.Id, processDataFromFactory.Id);
Assert.AreEqual(matProcessData.PostProcessData, processDataFromFactory.PostProcessData);
Assert.AreEqual(matProcessData.PreProcessData, processDataFromFactory.PreProcessData);
Assert.AreEqual(matProcessData.ProcessData, processDataFromFactory.ProcessData);
Assert.AreEqual(matProcessData.ProcessStage, processDataFromFactory.ProcessStage);
Assert.AreEqual(matProcessData.ProcessType, processDataFromFactory.ProcessType);
}
public void get_process_data_by_processref_returns_getprocessdataresponse_object()
{
//arrange
string processRef = faker.Random.Guid().ToString();
var request = new GetProcessDataRequest {
processRef = processRef
};
var response = new MatProcessData();
//act
mockMatGateway.Setup(x => x.GetProcessData(processRef)).Returns(response);
var result = processDataUseCase.ExecuteGet(request);
//assert
Assert.IsInstanceOf <GetProcessDataResponse>(result);
Assert.IsInstanceOf <GetProcessDataRequest>(result.Request);
Assert.IsInstanceOf <MatProcessData>(result.ProcessData);
Assert.AreEqual(processRef, result.Request.processRef);
Assert.NotNull(result.GeneratedAt);
Assert.IsInstanceOf <DateTime>(result.GeneratedAt);
}
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 update_process_data_returns_updateprocessdataresponse_object()
{
//arrange
var processRef = faker.Random.Guid().ToString();
var request = new UpdateProcessDataRequest {
processDataToUpdate = new MatUpdateProcessData()
};
var response = new MatProcessData();
//act
mockMatGateway.Setup(x => x.UpdateProcessData(It.IsAny <UpdateDefinition <BsonDocument> >(), It.IsAny <string>())).Returns(response);
var result = processDataUseCase.ExecuteUpdate(request);
//assert
Assert.IsInstanceOf <UpdateProcessDataResponse>(result);
Assert.IsInstanceOf <UpdateProcessDataRequest>(result.Request);
Assert.IsInstanceOf <MatProcessData>(result.UpdatedProcessData);
Assert.AreEqual(JsonConvert.SerializeObject(new MatProcessData()), JsonConvert.SerializeObject(result.UpdatedProcessData));
Assert.NotNull(result.GeneratedAt);
Assert.IsInstanceOf <DateTime>(result.GeneratedAt);
}
public void given_an_invalid_request_object_controller_should_return_bad_request()
{
var requestObject = new MatProcessData();
var request = new UpdateProcessDataRequest()
{
processDataToUpdate = new MatUpdateProcessData()
};
var validationErrorList = new List <ValidationFailure>();
validationErrorList.Add(new ValidationFailure(faker.Random.Word(), faker.Random.Word()));
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.
_mockValidatorUpdate.Setup(x => x.Validate(request)).Returns(fakeValidationResult);
var response = _processDataController.UpdateExistingProcessDocument(request);
var okResult = (ObjectResult)response;
var resultContent = okResult.Value;
Assert.NotNull(response);
Assert.NotNull(okResult);
Assert.NotNull(resultContent);
Assert.AreEqual(400, okResult.StatusCode);
}
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 UpdateProcessDataResponse(UpdateProcessDataRequest request, MatProcessData processData, DateTime generatedAt)
{
Request = request;
GeneratedAt = generatedAt;
UpdatedProcessData = processData;
}
public GetProcessDataResponse(GetProcessDataRequest request, MatProcessData processData, DateTime generatedAt)
{
Request = request;
GeneratedAt = generatedAt;
ProcessData = processData;
}
public MaTProcessDataTests()
{
processData = new MatProcessData();
}
public void set_up()
{
processData = new MatProcessData();
}
