public void test_that_controller_returns_correct_message_and_status_code_when_no_document_was_found_for_update()
{
//arange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = faker.Random.Word(),
anyField = faker.Random.Words(),
numberField = faker.Random.Number()
};
//set up Guid to filder by
var processRef = faker.Random.Guid().ToString();
var errorResponse = $"Document with reference {processRef} was not found in the database." +
$" An update is not possible on non-existent documents.";
var request = new UpdateProcessDataRequest()
{
processRef = processRef, processDataToUpdate = matProcessData
};
_mockUsecase.Setup(x => x.ExecuteUpdate(request)).Throws <DocumentNotFound>();
_mockValidatorUpdate.Setup(x => x.Validate(request)).Returns(new FV.ValidationResult());
//act
var actualResponse = _processDataController.UpdateExistingProcessDocument(request);
var result = (ObjectResult)actualResponse;
var resultContent = result.Value;
//assert
Assert.NotNull(actualResponse);
Assert.NotNull(result);
Assert.NotNull(resultContent);
Assert.AreEqual(errorResponse, resultContent);
Assert.AreEqual(200, result.StatusCode);
}
public void can_check_for_fields_to_be_updated_from_a_request_object_and_prepare_update_definition()
{
//arrange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = _faker.Random.Word(),
anyField = _faker.Random.Words(),
numberField = _faker.Random.Number()
};
matProcessData.DateLastModified = _faker.Date.Recent();
var expectedUpdateDefinition = Builders <BsonDocument> .Update.Combine(
Builders <BsonDocument> .Update.Set("dateLastModified", matProcessData.DateLastModified),
Builders <BsonDocument> .Update.Set("processDataAvailable", true),
Builders <BsonDocument> .Update.Set("processData", BsonDocument.Parse(JsonConvert.SerializeObject(matProcessData.ProcessData))));
//act
UpdateDefinition <BsonDocument> processDataUpdateDefinition = UpdateProcessDocumentHelper.PrepareFieldsToBeUpdated(matProcessData);
//assert
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <BsonDocument>();
//compare what the update definitions render to
Assert.AreEqual(expectedUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString(),
processDataUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString());
}
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_update_controller_returns_correct_500_status_code_when_an_error_has_occured()
{
//arange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = faker.Random.Word(),
anyField = faker.Random.Words(),
numberField = faker.Random.Number()
};
//set up Guid to filder by
var processRef = faker.Random.Guid().ToString();
var request = new UpdateProcessDataRequest()
{
processRef = processRef, processDataToUpdate = matProcessData
};
_mockUsecase.Setup(x => x.ExecuteUpdate(request)).Throws <AggregateException>();
_mockValidatorUpdate.Setup(x => x.Validate(request)).Returns(new FV.ValidationResult());
//act
var actualResponse = _processDataController.UpdateExistingProcessDocument(request);
var result = (ObjectResult)actualResponse;
var resultContent = result.Value;
//assert
Assert.NotNull(actualResponse);
Assert.NotNull(result);
Assert.NotNull(resultContent);
Assert.AreEqual(500, result.StatusCode);
}
private bool ValidateAnUpdateIsProvided(MatUpdateProcessData request)
{ //user must provide at least one object to update
if (request.PostProcessData != null)
{
return(true);
}
else if (request.PreProcessData != null)
{
return(true);
}
else if (request.ProcessDataSchemaVersion != 0)
{
return(true);
}
else if (request.ProcessData != null)
{
return(true);
}
else if (request.ProcessStage != null)
{
return(true);
}
else if (request.DateCompleted != null && request.DateCompleted != DateTime.MinValue)
{
return(true);
}
return(false); //if non of the objects were non empty
}
public void can_check_for_fields_to_be_updated_from_a_request_object_correctly(string firstField)
{
//this test ensures that the update definition is built correctly and will be recognised as different when compared to a different
//update definition
//arrange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = _faker.Random.Word(),
anyField = _faker.Random.Words(),
numberField = _faker.Random.Number()
};
matProcessData.DateLastModified = _faker.Date.Recent();
var expectedUpdateDefinition = Builders <BsonDocument> .Update.Combine(
Builders <BsonDocument> .Update.Set("dateLastModified", matProcessData.DateLastModified),
Builders <BsonDocument> .Update.Set("processDataa", matProcessData.ProcessData));
//act
UpdateDefinition <BsonDocument> processDataUpdateDefinition = UpdateProcessDocumentHelper.PrepareFieldsToBeUpdated(matProcessData);
//assert
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <BsonDocument>();
//test that update definitions are succesfully recognised as different
Assert.AreNotEqual(expectedUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString(),
processDataUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString());
}
public void update_process_controller_end_to_end_testing_error_message_when_document_is_not_found()
{
//arrange
var dataToUpdate = new MatUpdateProcessData();
var processRef = _faker.Random.Guid().ToString();
dataToUpdate.PreProcessData = new
{
randomField = "abc"
};
var request = new UpdateProcessDataRequest()
{
processDataToUpdate = dataToUpdate, processRef = processRef
};
//act
var response = _processDataController.UpdateExistingProcessDocument(request);
var okResult = (ObjectResult)response;
var error = okResult.Value;
//assert
Assert.AreEqual(200, okResult.StatusCode);
Assert.AreEqual($"Document with reference { processRef} was not found in the database." +
$" An update is not possible on non-existent documents.", error);
}
public void given_missing_fields_to_update_in_request_object_validator_returns_correct_error_message()
{
var updateData = new MatUpdateProcessData();
var processRef = randomGuid;
var request = new UpdateProcessDataRequest()
{
processDataToUpdate = updateData
};
_updateProcessDocValidator.ShouldHaveValidationErrorFor(r => r.processDataToUpdate, request.processDataToUpdate).WithErrorMessage("At least one object must be providef for an update.");
}
public void given_an_invalid_process_ref_validator_returns_correct_error_message(string processReference)
{
var updateData = new MatUpdateProcessData();
var processRef = processReference;
var request = new UpdateProcessDataRequest()
{
processRef = processRef, processDataToUpdate = updateData
};
_updateProcessDocValidator.ShouldHaveValidationErrorFor(r => r.processRef, request).WithErrorMessage("You need to provide a valid process reference.");
}
public static UpdateDefinition <BsonDocument> PrepareFieldsToBeUpdated(MatUpdateProcessData matProcessData)
{
var listOfUpdates = new List <UpdateDefinition <BsonDocument> >();
//mandatory field
var dateLastModified = Builders <BsonDocument> .Update.Set("dateLastModified", matProcessData.DateLastModified);
listOfUpdates.Add(dateLastModified);
//update has occurred
var processDataAvailable = Builders <BsonDocument> .Update.Set("processDataAvailable", true);
listOfUpdates.Add(processDataAvailable);
if (matProcessData.DateCompleted != DateTime.MinValue)
{
var dateCompleted = Builders <BsonDocument> .Update.Set("dateCompleted", matProcessData.DateCompleted);
listOfUpdates.Add(dateCompleted);
}
if (matProcessData.PostProcessData != null)
{
var postProcessData = Builders <BsonDocument> .Update.Set("postProcessData",
BsonDocument.Parse(JsonConvert.SerializeObject(matProcessData.PostProcessData)));
listOfUpdates.Add(postProcessData);
}
if (matProcessData.PreProcessData != null)
{
var preProcessData = Builders <BsonDocument> .Update.Set("preProcessData",
BsonDocument.Parse(JsonConvert.SerializeObject(matProcessData.PreProcessData)));
listOfUpdates.Add(preProcessData);
}
if (matProcessData.ProcessData != null)
{
var processData = Builders <BsonDocument> .Update.Set("processData",
BsonDocument.Parse(JsonConvert.SerializeObject(matProcessData.ProcessData)));
listOfUpdates.Add(processData);
}
if (matProcessData.ProcessDataSchemaVersion != 0)
{
var processDataSchemaVersion = Builders <BsonDocument> .Update.Set("dataSchemaVersion", matProcessData.ProcessDataSchemaVersion);
listOfUpdates.Add(processDataSchemaVersion);
}
if (!string.IsNullOrWhiteSpace(matProcessData.ProcessStage))
{
var processStage = Builders <BsonDocument> .Update.Set("processStage", matProcessData.ProcessStage);
listOfUpdates.Add(processStage);
}
return(Builders <BsonDocument> .Update.Combine(listOfUpdates));
}
public void given_a_valid_request_validator_should_return_no_errors()
{
var updateData = new MatUpdateProcessData();
var processRef = randomGuid;
updateData.DateCompleted = _faker.Date.Recent();
var request = new UpdateProcessDataRequest()
{
processRef = processRef, processDataToUpdate = updateData
};
_updateProcessDocValidator.ShouldNotHaveValidationErrorFor(r => r.processDataToUpdate, request.processDataToUpdate);
}
public void update_process_data_verify_gateway_calls_database_with_parameters(string processRef)
{
//arrange
var dataToUpdate = new MatUpdateProcessData();
var request = new UpdateProcessDataRequest {
processRef = processRef, processDataToUpdate = dataToUpdate
};
//act
var result = processDataUseCase.ExecuteUpdate(request);
//assert
mockMatGateway.Verify(v => v.UpdateProcessData(It.IsAny <UpdateDefinition <BsonDocument> >(), It.Is <string>(i => i == processRef)), Times.Once);
}
public void update_process_data_gateway_call_returns_updateprocsesdataresponse_object()
{
//arrange
var updateData = new MatUpdateProcessData();
var request = new UpdateProcessDataRequest()
{
processDataToUpdate = updateData
};
//act
mockMatGateway.Setup(x => x.UpdateProcessData(It.IsAny <UpdateDefinition <BsonDocument> >(), It.IsAny <string>())).Returns(new MatProcessData());
var result = processDataUseCase.ExecuteUpdate(request);
//assert
Assert.IsInstanceOf <MatProcessData>(result.UpdatedProcessData);
Assert.IsInstanceOf <UpdateProcessDataResponse>(result);
}
public void update_process_controller_end_to_end_testing_for_bad_request_given_invalid_request()
{
//arrange
var dataToUpdate = new MatUpdateProcessData();
var processRef = _faker.Random.Word();
var request = new UpdateProcessDataRequest()
{
processRef = processRef, processDataToUpdate = dataToUpdate
};
//act
var response = _processDataController.UpdateExistingProcessDocument(request);
var okResult = (ObjectResult)response;
//assert
Assert.AreEqual(400, okResult.StatusCode); //check if it was a bad request
}
public void test_if_object_to_be_updated_is_not_found_exception_is_thrown()
{
//arrange
//object to update
var objectToUpdate = new MatUpdateProcessData();
objectToUpdate.DateLastModified = _faker.Date.Recent();
objectToUpdate.ProcessData = new
{
firstField = _faker.Random.Word(),
anyField = _faker.Random.Words(),
numberField = _faker.Random.Number()
};
var processRef = _faker.Random.Guid().ToString();
//get update definition
var updateDefinition = UpdateProcessDocumentHelper.PrepareFieldsToBeUpdated(objectToUpdate);
//assert
Assert.Throws <DocumentNotFound>(() => processDataGateway.UpdateProcessData(updateDefinition, processRef));
}
public void ensure_update_controller_calls_use_case_with_request_object()
{
//arrange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = faker.Random.Word()
};
//set up Guid to filder by
var processRef = faker.Random.Guid().ToString();
var request = new UpdateProcessDataRequest()
{
processRef = processRef, processDataToUpdate = matProcessData
};
_mockValidatorUpdate.Setup(x => x.Validate(request)).Returns(new FV.ValidationResult());
var actualResponse = _processDataController.UpdateExistingProcessDocument(request);
//verify usecase is called with an update process request object
_mockUsecase.Verify(x => x.ExecuteUpdate((It.Is <UpdateProcessDataRequest>(i => i == request))));
}
public void given_an_update_object_when_update_process_data_method_is_called_the_controller_returns_correct_json_response()
{
//arange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = faker.Random.Word(),
anyField = faker.Random.Words(),
numberField = faker.Random.Number()
};
//set up Guid to filder by
var processRef = faker.Random.Guid().ToString();
var request = new UpdateProcessDataRequest()
{
processRef = processRef, processDataToUpdate = matProcessData
};
var response = new UpdateProcessDataResponse(request, new MatProcessData(), DateTime.Now);
_mockValidatorUpdate.Setup(x => x.Validate(request)).Returns(new FV.ValidationResult());
_mockUsecase.Setup(x => x.ExecuteUpdate(request)).Returns(response);
//act
var actualResponse = _processDataController.UpdateExistingProcessDocument(request);
var okResult = (OkObjectResult)actualResponse;
var resultContent = (UpdateProcessDataResponse)okResult.Value;
//assert
Assert.NotNull(actualResponse);
Assert.NotNull(okResult);
Assert.IsInstanceOf <UpdateProcessDataResponse>(resultContent);
Assert.NotNull(resultContent);
Assert.AreEqual(JsonConvert.SerializeObject(response), JsonConvert.SerializeObject(resultContent));
Assert.AreEqual(200, okResult.StatusCode);
}
public void set_up()
{
processData = new MatUpdateProcessData();
}
