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_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());
}
static void Main(string[] args)
{
List <Model.BetEasyModel> betEasyModels = new List <Model.BetEasyModel>();
DirectoryInfo feedData = new DirectoryInfo("FeedData");
FileInfo[] files = feedData.GetFiles();
foreach (var file in files)
{
IProcessData processData = ProcessDataFactory.GetProcessDataType(file.Extension.ToLower());
if (processData != null)
{
var model = processData.Transform(file);
if (model != null)
{
betEasyModels.AddRange(model);
}
}
}
betEasyModels = betEasyModels.OrderBy(t => t.Price).ToList();
foreach (var model in betEasyModels)
{
Console.WriteLine(string.Format("Horse Name : {0} Price : {1}", model.HorseName, model.Price));
}
Console.ReadLine();
}
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 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 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 MatProcessData GetProcessData(string processRef)
{
//retrieve data by id
var filter = Builders <BsonDocument> .Filter.Eq("_id", processRef);
//we will never expect more than one JSON documents matching an ID so we always choose the first/default result
var result = matDbContext.getCollection().FindAsync(filter).Result.FirstOrDefault();
//if document does not exist in the DB, then thrown a corresponsing error.
if (result == null)
{
throw new DocumentNotFound();
}
return(ProcessDataFactory.CreateProcessDataObject(result));
}
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 MatProcessData UpdateProcessData(UpdateDefinition <BsonDocument> updateDefinition, string id)
{
//return updated document
var options = new FindOneAndUpdateOptions <BsonDocument>();
options.ReturnDocument = ReturnDocument.After;
//query by
var filter = Builders <BsonDocument> .Filter.Eq("_id", id);
//find and update
var result = matDbContext.getCollection().FindOneAndUpdate(filter, updateDefinition, options);
//if empty result, the document to be updated was not found
if (result == null)
{
throw new DocumentNotFound();
}
return(ProcessDataFactory.CreateProcessDataObject(result));
}
public void can_create_mat_process_data_object_from_populated_object()
{
//arrange
var matProcessData = ProcessDataHelper.CreateProcessDataObject();
//act
var processDataFromFactory = ProcessDataFactory.CreateProcessDataObject(BsonDocument.Parse(JsonConvert.SerializeObject(matProcessData)));
//assert
Assert.Equal(matProcessData.Id, processDataFromFactory.Id);
Assert.Equal(matProcessData.ProcessType.value, processDataFromFactory.ProcessType.value);
Assert.Equal(matProcessData.ProcessType.name, processDataFromFactory.ProcessType.name);
Assert.Equal(matProcessData.ProcessDataAvailable, processDataFromFactory.ProcessDataAvailable);
Assert.Equal(matProcessData.ProcessDataSchemaVersion, processDataFromFactory.ProcessDataSchemaVersion);
Assert.Equal(matProcessData.ProcessStage, processDataFromFactory.ProcessStage);
Assert.Equal(matProcessData.LinkedProcessId, processDataFromFactory.LinkedProcessId);
Assert.Equal(matProcessData.PreProcessData, processDataFromFactory.PreProcessData);
Assert.Equal(matProcessData.ProcessData, processDataFromFactory.ProcessData);
Assert.Equal(matProcessData.PostProcessData, processDataFromFactory.PostProcessData);
}
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 List <MatProcessData> GetProcessDataByIDs(string[] refs)
{
try
{
var filter = Builders <BsonDocument> .Filter.In("_id", refs);
var result = processDbContext.getCollection().FindAsync(filter).Result;
List <MatProcessData> docs = new List <MatProcessData>();
foreach (var doc in result.ToList())
{
docs.Add(ProcessDataFactory.CreateProcessDataObject(doc));
}
return(docs);
}
catch
{
throw new MaTProcessApiException("Unable to get home check details from process database");
}
}
public static List <PassengerProcessedData> ProcessPassengersData(List <Passenger> passengers, Route route)
{
var passengerProcessedData = new List <PassengerProcessedData>();
foreach (var passenger in passengers)
{
ProcessDataFactory factory = null;
switch (passenger.MembershipType)
{
case MembershipType.general:
factory = new GeneralPassengerFactory(passenger, route);
break;
case MembershipType.airline:
factory = new AirlinePassengerFactory(passenger, route);
break;
case MembershipType.loyalty:
factory = new LoyaltyPassengerFactory(passenger, route);
break;
default:
throw new ArgumentOutOfRangeException();
}
PassengerData passengerData = factory.GetPassengerData();
if (passengerData != null)
{
passengerProcessedData.Add(new PassengerProcessedData()
{
Bags = passengerData.TotalBags,
LoyaltyPointUsed = passengerData.LoyaltyPointUsed,
ProcessedRevnue = passengerData.TicketPrice
});
}
}
return(passengerProcessedData);
}
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 ProcessDataFactory_XML_Pass()
{
IProcessData processData = ProcessDataFactory.GetProcessDataType(".xml");
Assert.Equal(typeof(ProcessXMLData), processData.GetType());
}
public void ProcessDataFactory_OtherType_Pass()
{
IProcessData processData = ProcessDataFactory.GetProcessDataType(".jpeg");
Assert.Null(processData);
}
public void ProcessDataFactory_JSON_Pass()
{
IProcessData processData = ProcessDataFactory.GetProcessDataType(".json");
Assert.Equal(typeof(ProcessJSONData), processData.GetType());
}
