fable 3.0.85 → 3.0.87

package/source/services/Fable-Service-Operation.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 const _OperationStatePrototypeString = JSON.stringify(require('./Fable-Service-Operation-DefaultSettings.js'));
 
@@ -18,15 +18,108 @@ class FableOperation extends libFableServiceBase
 
 		this.state = JSON.parse(_OperationStatePrototypeString);
 
+		this.stepMap = {};
+		this.stepFunctions = {};
+
 		// Match the service instantiation to the operation.
 		this.state.Metadata.Hash = this.Hash;
 		this.state.Metadata.UUID = this.UUID;
 
-		this.name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.UUID}`;
+		this.state.Metadata.Name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.UUID}`;
+		this.name = this.state.Metadata.Name;
 
 		this.log = this;
 	}
 
+	execute(fExecutionCompleteCallback)
+	{
+		if (this.state.Status.TimeStart)
+		{
+			return fExecutionCompleteCallback(new Error(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} has already been executed!`));
+		}
+
+		this.state.Status.TimeStart = +new Date();
+
+		let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+		for (let i = 0; i < this.state.Steps; i++)
+		{
+			tmpAnticipate.anticipate(this.stepFunctions[this.state.Steps[i].GUIDStep].bind(this));
+		}
+
+		// Wait for the anticipation to complete
+		tmpAnticipate.wait(
+			(pError) =>
+			{
+				this.state.Status.TimeEnd = +new Date();
+				return fExecutionCompleteCallback();
+			});
+	}
+
+/*
+	TODO: I've gone back and forth on whether this should be an object, JSON 
+	object prototype, or set of functions here.  Discuss with colleagues!
+*/
+	addStep(pGUIDStep, fStepFunction, pStepName, pStepDescription, pStepMetadata)
+	{
+		let tmpStep = {};
+		tmpStep.GUIDStep = (typeof(pGUIDStep) !== 'undefined') ? pGUIDStep : `STEP-${this.state.Steps.length}-${this.fable.DataGeneration.randomNumericString()}`;
+		tmpStep.Name = (typeof(pStepName) !== 'undefined') ? pStepName : `Step [${tmpStep.GUIDStep}]`;
+		tmpStep.Description = (typeof(pStepDescription) !== 'undefined') ? pStepDescription : `Step execution of ${tmpStep.Name}.`;
+		// TODO: Right now this allows an Array... do we want to block that?
+		tmpStep.Metadata = (typeof(pStepMetadata) === 'object') ? pStepMetadata : {};
+
+		tmpStep.TimeStart = false;
+		tmpStep.TimeEnd = false;
+
+		// There is an array of steps, in the Operation State itself ... push a step there
+		this.state.Steps.push(tmpStep);
+
+		this.stepMap[tmpStep.GUIDStep]
+		this.stepFunctions[tmpStep.GUIDStep] = fStepFunction;
+
+		this.state.Status.StepCount++;
+		return tmpStep;
+	}
+
+	getStep(pGUIDStep)
+	{
+		if (this.stepMap.hasOwnProperty(pGUIDStep))
+		{
+			return this.stepMap[pGUIDStep];
+		}
+
+		return false;
+	}
+
+	startStep(pGUIDStep)
+	{
+		let tmpStep = this.getStep(pGUIDStep);
+
+		if (tmpStep === false)
+		{
+			return false;
+		}
+
+		tmpStep.TimeStart = +new Date();
+
+		return tmpStep;
+	}
+
+	stopStep(pGUIDStep)
+	{
+		let tmpStep = this.getStep(pGUIDStep);
+
+		if (tmpStep === false)
+		{
+			return false;
+		}
+
+		tmpStep.TimeEnd = +new Date();
+
+		return tmpStep;
+	}
+
 	writeOperationLog(pLogLevel, pLogText, pLogObject)
 	{
 		this.state.Log.push(`${new Date().toUTCString()} [${pLogLevel}]: ${pLogText}`);
@@ -47,6 +140,7 @@ class FableOperation extends libFableServiceBase
 		}
 	}
 
+
 	trace(pLogText, pLogObject)
 	{
 		this.writeOperationLog('TRACE', pLogText, pLogObject);
@@ -85,6 +179,7 @@ class FableOperation extends libFableServiceBase
 		this.fable.log.fatal(pLogText, pLogObject);
 	}
 
+
 	/************************************************************************
 	 * BEGINNING OF -->  Telemetry Helpers
 	 */
@@ -263,7 +358,6 @@ class FableOperation extends libFableServiceBase
 			}
 		}
 	}
-
 	// logMemoryResourcesUsed()
 	// {
 	//

package/source/services/Fable-Service-RestClient.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 const libSimpleGet = require('simple-get');
 const libCookie = require('cookie');

package/source/services/Fable-Service-Template.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 class FableServiceTemplate extends libFableServiceBase
 {

package/source/services/Fable-Service-Utility.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 // TODO: These are still pretty big -- consider the smaller polyfills
 const libAsyncWaterfall = require('async.waterfall');
@@ -56,7 +56,7 @@ class FableServiceUtility extends libFableServiceBase
 	// with the added twist of returning a precompiled function ready to go.
 	template(pTemplateText, pData)
 	{
-		let tmpTemplate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Template');
+		let tmpTemplate = this.fable.instantiateServiceProviderWithoutRegistration('Template');
 
 		return tmpTemplate.buildTemplateFunction(pTemplateText, pData);
 	}
@@ -64,7 +64,7 @@ class FableServiceUtility extends libFableServiceBase
 	// Build a template function from a template hash, and, register it with the service provider
 	buildHashedTemplate(pTemplateHash, pTemplateText, pData)
 	{
-		let tmpTemplate = this.fable.serviceManager.instantiateServiceProvider('Template', {}, pTemplateHash);
+		let tmpTemplate = this.fable.instantiateServiceProvider('Template', {}, pTemplateHash);
 
 		this.templates[pTemplateHash] = tmpTemplate.buildTemplateFunction(pTemplateText, pData);
 

package/test/Anticipate_tests.js

@@ -26,7 +26,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpAnticipate = testFable.serviceManager.instantiateServiceProvider('Anticipate');
+									let tmpAnticipate = testFable.instantiateServiceProvider('Anticipate');
 									tmpAnticipate.anticipate(function (fCallback)
 									{
 										testFable.log.info('Operation First test timeout entered...');
@@ -58,7 +58,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpAnticipate = testFable.serviceManager.instantiateServiceProvider('Anticipate');
+									let tmpAnticipate = testFable.instantiateServiceProvider('Anticipate');
 									tmpAnticipate.maxOperations = 2;
 									tmpAnticipate.anticipate(function (fCallback)
 									{

package/test/CSVParser_tests.js

@@ -30,7 +30,7 @@ suite
 					function(fDone)
 					{
 						let testFable = new libFable();
-						let tmpCSVParser = testFable.serviceManager.instantiateServiceProvider('CSVParser', {Name: 'Big Complex Integration Operation'}, 'CSV Parser-123');
+						let tmpCSVParser = testFable.instantiateServiceProvider('CSVParser', {Name: 'Big Complex Integration Operation'}, 'CSV Parser-123');
 						let tmpRecords = [];
 
 						const tmpReadline = libReadline.createInterface(

package/test/Cache_tests.js

@@ -28,7 +28,7 @@ suite
 					{
 						let testFable = new libFable();
 
-						let testCache = testFable.serviceManager.instantiateServiceProvider('ObjectCache');
+						let testCache = testFable.instantiateServiceProvider('ObjectCache');
 
 						testCache.maxLength = 2;
 

package/test/DataGeneration_tests.js

@@ -26,7 +26,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 									Expect(tmpDataGeneration.randomIntegerUpTo(100)).to.be.within(0, 100);
 									return fTestComplete();
 								}
@@ -37,7 +37,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 									Expect(tmpDataGeneration.randomNumericString()).to.be.a('string');
 									Expect(tmpDataGeneration.randomNumericString().length).to.equal(10);
 									return fTestComplete();
@@ -49,7 +49,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 									testFable.log.info(`Random color: ${tmpDataGeneration.randomColor()}`);
 									Expect(tmpDataGeneration.randomColor()).to.be.a('string');
 									return fTestComplete();
@@ -61,7 +61,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 									testFable.log.info(`Random Day of Week: ${tmpDataGeneration.randomDayOfWeek()}`);
 									Expect(tmpDataGeneration.randomDayOfWeek()).to.be.a('string');
 									return fTestComplete();
@@ -73,7 +73,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 									testFable.log.info(`Random Month: ${tmpDataGeneration.randomMonth()}`);
 									Expect(tmpDataGeneration.randomMonth()).to.be.a('string');
 									return fTestComplete();
@@ -85,7 +85,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 									testFable.log.info(`Random Name: ${tmpDataGeneration.randomName()}`);
 									Expect(tmpDataGeneration.randomName()).to.be.a('string');
 									return fTestComplete();
@@ -97,7 +97,7 @@ suite
 								function (fTestComplete)
 								{
 									let testFable = new libFable();
-									let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+									let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 									testFable.log.info(`Random Surname: ${tmpDataGeneration.randomSurname()}`);
 									Expect(tmpDataGeneration.randomSurname()).to.be.a('string');
 									return fTestComplete();

package/test/DateManipulation_tests.js

@@ -29,7 +29,7 @@ suite
 					function(fDone)
 					{
 						let testFable = new libFable();
-						let tmpDates = testFable.serviceManager.instantiateServiceProvider('Dates');
+						let tmpDates = testFable.instantiateServiceProvider('Dates');
 
 						testFable.log.info(`Guessing your timezone: ${tmpDates.dayJS.tz.guess()}`);
 

package/test/FableOperation_tests.js

@@ -27,7 +27,7 @@ suite
 					function()
 					{
 						let testFable = new libFable();
-						let tmpOperation = testFable.serviceManager.instantiateServiceProvider('Operation', {Name: 'Big Complex Integration Operation'}, 'INTEGRATION-123');
+						let tmpOperation = testFable.instantiateServiceProvider('Operation', {Name: 'Big Complex Integration Operation'}, 'INTEGRATION-123');
 						Expect(tmpOperation).to.be.an('object');
 						Expect(testFable.servicesMap.Operation['INTEGRATION-123']).to.equal(tmpOperation);
 						Expect(testFable.servicesMap.Operation['BADHASH']).to.be.undefined;
@@ -43,11 +43,11 @@ suite
 					function()
 					{
 						let testFable = new libFable();
-						let tmpOperation = testFable.serviceManager.instantiateServiceProvider('Operation', {Name: 'Big Complex Integration Operation'}, 'INTEGRATION-123');;
+						let tmpOperation = testFable.instantiateServiceProvider('Operation', {Name: 'Big Complex Integration Operation'}, 'INTEGRATION-123');;
 						Expect(tmpOperation).to.be.an('object');
 						Expect(tmpOperation.name).to.equal('Big Complex Integration Operation');
 
-						let tmpCollisionOperation = testFable.serviceManager.instantiateServiceProvider('Operation', {Name: 'Another Big Complex Integration Operation with Colliding Name'}, 'INTEGRATION-123');;
+						let tmpCollisionOperation = testFable.instantiateServiceProvider('Operation', {Name: 'Another Big Complex Integration Operation with Colliding Name'}, 'INTEGRATION-123');;
 						Expect(tmpCollisionOperation).to.be.an('object');
 						Expect(tmpCollisionOperation.name).to.equal('Another Big Complex Integration Operation with Colliding Name');
 
@@ -61,7 +61,7 @@ suite
 					function()
 					{
 						let testFable = new libFable();
-						let tmpOperation = testFable.serviceManager.instantiateServiceProvider('Operation', {Name:'Another Big Complex Integration Operation'});
+						let tmpOperation = testFable.instantiateServiceProvider('Operation', {Name:'Another Big Complex Integration Operation'});
 						Expect(tmpOperation).to.be.an('object');
 						Expect(testFable.servicesMap.Operation.hasOwnProperty(tmpOperation.Hash)).to.equal(true);
 						Expect(tmpOperation.state.Log.length).to.equal(0);
@@ -80,6 +80,35 @@ suite
 						Expect(tmpOperation.state.Errors.length).to.equal(4);
 					}
 				);
+				test
+				(
+					'Timing Stuff for Operations',
+					function(fDone)
+					{
+						let testFable = new libFable();
+						let tmpOperation = testFable.instantiateServiceProvider('Operation', {Name:'The last operation in town.'});
+						Expect(tmpOperation).to.be.an('object');
+						Expect(testFable.servicesMap.Operation.hasOwnProperty(tmpOperation.Hash)).to.equal(true);
+						Expect(tmpOperation.state.Log.length).to.equal(0);
+						let tmpText = `Operation ${tmpOperation.Hash} starting up...`;
+						tmpOperation.log.info(tmpText);
+						Expect(tmpOperation.state.Log.length).to.equal(1);
+						Expect(tmpOperation.state.Log[0]).to.contain(tmpText);
+
+						tmpOperation.addStep('001-Login',
+							(fStepComplete) =>
+							{
+								setTimeout(
+									() =>
+									{
+										tmpOperation.log.trace('Login thingy complete!');
+										return fStepComplete();
+									}, 150);
+							}, 'Example step 1!');
+
+						tmpOperation.execute(fDone);
+					}
+				);
 			}
 		);
 	}

package/test/FableServiceManager_tests.js

@@ -87,10 +87,10 @@ suite
 								function ()
 								{
 									testFable = new libFable();
-									testFable.serviceManager.addServiceType('SimpleService');
-									testFable.serviceManager.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'SimpleService-123');
+									testFable.addServiceType('SimpleService');
+									testFable.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'SimpleService-123');
 
-									Expect(testFable.serviceManager.servicesMap['SimpleService']['SimpleService-123']).to.be.an('object');
+									Expect(testFable.servicesMap['SimpleService']['SimpleService-123']).to.be.an('object');
 								}
 							);
 						test
@@ -99,17 +99,17 @@ suite
 								function ()
 								{
 									testFable = new libFable();
-									testFable.serviceManager.addServiceType('SimpleService');
-									testFable.serviceManager.extraServiceInitialization = (pService) =>
+									testFable.addServiceType('SimpleService');
+									testFable.extraServiceInitialization = (pService) =>
 									{
 										pService.MyFancyProperty = 'Fancy';
 										return pService;
 									}
-									testFable.serviceManager.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'TheBestOne');
+									testFable.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'TheBestOne');
 
-									Expect(testFable.serviceManager.services.SimpleService).to.be.an('object');
-									Expect(testFable.serviceManager.services.SimpleService.MyFancyProperty).to.equal('Fancy');
-									Expect(testFable.serviceManager.servicesMap.SimpleService.TheBestOne.MyFancyProperty).to.equal('Fancy');
+									Expect(testFable.services.SimpleService).to.be.an('object');
+									Expect(testFable.services.SimpleService.MyFancyProperty).to.equal('Fancy');
+									Expect(testFable.servicesMap.SimpleService.TheBestOne.MyFancyProperty).to.equal('Fancy');
 								}
 							);
 						test
@@ -118,16 +118,16 @@ suite
 								function ()
 								{
 									testFable = new libFable();
-									testFable.serviceManager.addServiceType('SimpleService', SimpleService);
-									testFable.serviceManager.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'SimpleService-123');
+									testFable.addServiceType('SimpleService', SimpleService);
+									testFable.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'SimpleService-123');
 
-									Expect(testFable.serviceManager.servicesMap['SimpleService']['SimpleService-123']).to.be.an('object');
+									Expect(testFable.servicesMap['SimpleService']['SimpleService-123']).to.be.an('object');
 
-									Expect(testFable.serviceManager.services['SimpleService']).to.be.an('object');
+									Expect(testFable.services['SimpleService']).to.be.an('object');
 
-									testFable.serviceManager.services.SimpleService.doSomething();
+									testFable.services.SimpleService.doSomething();
 
-									Expect(testFable.serviceManager.services['SimpleService'].Hash).to.equal('SimpleService-123');
+									Expect(testFable.services['SimpleService'].Hash).to.equal('SimpleService-123');
 								}
 							);
 						test
@@ -137,13 +137,13 @@ suite
 								{
 									let testFable = new libFable({});
 
-									testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+									testFable.addServiceType('SimpleService', SimpleService);
 
-									testFable.serviceManager.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'SimpleService-13');
+									testFable.instantiateServiceProvider('SimpleService', { SomeOption: true }, 'SimpleService-13');
 
-									testFable.serviceManager.servicesMap['SimpleService']['SimpleService-13'].doSomething();
+									testFable.servicesMap['SimpleService']['SimpleService-13'].doSomething();
 
-									Expect(testFable.serviceManager.servicesMap['SimpleService']['SimpleService-13']).to.be.an('object');
+									Expect(testFable.servicesMap['SimpleService']['SimpleService-13']).to.be.an('object');
 								}
 							);
 
@@ -154,10 +154,10 @@ suite
 								{
 									let testFable = new libFable({});
 
-									testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+									testFable.addServiceType('SimpleService', SimpleService);
 
-									let tmpService = testFable.serviceManager.instantiateServiceProviderWithoutRegistration('SimpleService', { SomeOption: true }, 'SimpleService-99');
-									let tmpServiceFromPrototype = testFable.serviceManager.instantiateServiceProviderFromPrototype('SimpleService', { SomeOption: true }, 'SimpleService-100', SimpleService);
+									let tmpService = testFable.instantiateServiceProviderWithoutRegistration('SimpleService', { SomeOption: true }, 'SimpleService-99');
+									let tmpServiceFromPrototype = testFable.instantiateServiceProviderFromPrototype('SimpleService', { SomeOption: true }, 'SimpleService-100', SimpleService);
 
 									Expect(testFable.servicesMap.SimpleService['SimpleService-99']).to.be.an('undefined');
 									Expect(testFable.servicesMap.SimpleService['SimpleService-100']).to.be.an('object');
@@ -174,29 +174,29 @@ suite
 								{
 									let testFable = new libFable({});
 
-									testFable.serviceManager.addServiceType('SimpleService', SimpleService);
-									testFable.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+									testFable.addServiceType('SimpleService', SimpleService);
+									testFable.addServiceType('DatabaseService', MockDatabaseService);
 
-									testFable.serviceManager.instantiateServiceProvider('SimpleService', { SomeOption: true });
-									testFable.serviceManager.services.SimpleService.doSomething();
+									testFable.instantiateServiceProvider('SimpleService', { SomeOption: true });
+									testFable.services.SimpleService.doSomething();
 
-									testFable.serviceManager.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'PrimaryConnection');
+									testFable.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'PrimaryConnection');
 
-									Expect(testFable.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+									Expect(testFable.services.DatabaseService.Hash).to.equal('PrimaryConnection');
 
-									testFable.serviceManager.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'SecondaryConnection');
+									testFable.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'SecondaryConnection');
 
-									Expect(testFable.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+									Expect(testFable.services.DatabaseService.Hash).to.equal('PrimaryConnection');
 
-									testFable.serviceManager.services.DatabaseService.connect();
-									testFable.serviceManager.services.DatabaseService.commit('Test Record');
+									testFable.services.DatabaseService.connect();
+									testFable.services.DatabaseService.commit('Test Record');
 
-									testFable.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'SecondaryConnection');
+									testFable.setDefaultServiceInstantiation('DatabaseService', 'SecondaryConnection');
 
-									testFable.serviceManager.services.DatabaseService.connect();
-									testFable.serviceManager.services.DatabaseService.commit('Another Test Record');
+									testFable.services.DatabaseService.connect();
+									testFable.services.DatabaseService.commit('Another Test Record');
 
-									Expect(testFable.serviceManager.services.DatabaseService.Hash).to.equal('SecondaryConnection');
+									Expect(testFable.services.DatabaseService.Hash).to.equal('SecondaryConnection');
 								}
 							);
 
@@ -239,7 +239,7 @@ suite
 
 									let testFable = new libFable({});
 
-									testFable.serviceManager.connectPreinitServiceProviderInstance(tmpCoreService);
+									testFable.connectPreinitServiceProviderInstance(tmpCoreService);
 
 									Expect(testFable.servicesMap.MockCoreService['MockCoreService-2']).to.be.an('object');
 									Expect(testFable.services.MockCoreService).to.be.an('object');
@@ -255,29 +255,29 @@ suite
 								{
 									let testFable = new libFable({});
 
-									testFable.serviceManager.addServiceType('SimpleService', SimpleService);
-									testFable.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+									testFable.addServiceType('SimpleService', SimpleService);
+									testFable.addServiceType('DatabaseService', MockDatabaseService);
 
-									testFable.serviceManager.instantiateServiceProvider('SimpleService', { SomeOption: true });
-									testFable.serviceManager.services.SimpleService.doSomething();
+									testFable.instantiateServiceProvider('SimpleService', { SomeOption: true });
+									testFable.services.SimpleService.doSomething();
 
-									testFable.serviceManager.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'PrimaryConnection');
+									testFable.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'PrimaryConnection');
 
-									Expect(testFable.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+									Expect(testFable.services.DatabaseService.Hash).to.equal('PrimaryConnection');
 
-									testFable.serviceManager.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'SecondaryConnection');
+									testFable.instantiateServiceProvider('DatabaseService', { ConnectionString: 'mongodb://localhost:27017/test' }, 'SecondaryConnection');
 
-									Expect(testFable.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+									Expect(testFable.services.DatabaseService.Hash).to.equal('PrimaryConnection');
 
-									testFable.serviceManager.services.DatabaseService.connect();
-									testFable.serviceManager.services.DatabaseService.commit('Test Record');
+									testFable.services.DatabaseService.connect();
+									testFable.services.DatabaseService.commit('Test Record');
 
-									Expect(testFable.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'TertiaryConnection')).to.be.false;
+									Expect(testFable.setDefaultServiceInstantiation('DatabaseService', 'TertiaryConnection')).to.be.false;
 
-									testFable.serviceManager.services.DatabaseService.connect();
-									testFable.serviceManager.services.DatabaseService.commit('Another Test Record');
+									testFable.services.DatabaseService.connect();
+									testFable.services.DatabaseService.commit('Another Test Record');
 
-									Expect(testFable.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+									Expect(testFable.services.DatabaseService.Hash).to.equal('PrimaryConnection');
 								}
 							);
 					}

package/test/FilePersistence_tests.js

@@ -11,8 +11,6 @@ var libFable = require('../source/Fable.js');
 var Chai = require("chai");
 var Expect = Chai.expect;
 
-// https://en.wiktionary.org/w/api.php?action=parse&prop=wikitext&format=json&page=dog
-
 suite
 (
 	'Fable FilePersistence',
@@ -34,7 +32,7 @@ suite
 					function(fTestComplete)
 					{
 						let testFable = new libFable();
-						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
+						let tmpFilePersistence = testFable.instantiateServiceProvider('FilePersistence');
 						Expect(tmpFilePersistence).is.an('object');
 						Expect(tmpFilePersistence.existsSync(`${__dirname}/../package.json`)).to.equal(true);
 						Expect(tmpFilePersistence.existsSync(`${__dirname}/package.json`)).to.equal(false);
@@ -42,13 +40,48 @@ suite
 					}
 				);
 				test
+				(
+					'Read a file line-by-line',
+					function(fTestComplete)
+					{
+						let testFable = new libFable();
+						let tmpFilePersistence = testFable.instantiateServiceProvider('FilePersistence');
+						let tmpFirstLine = 'id,book_id,best_book_id,work_id,books_count,isbn,isbn13,authors,original_publication_year,original_title,title,language_code,average_rating,ratings_count,work_ratings_count,work_text_reviews_count,ratings_1,ratings_2,ratings_3,ratings_4,ratings_5,image_url,small_image_url';
+
+						let tmpLineReader = tmpFilePersistence.lineReaderFactory(`${__dirname}/data/books.csv`,
+							(pLine) =>
+							{
+								if (tmpFirstLine)
+								{
+									Expect(pLine).to.equal(tmpFirstLine);
+									tmpFirstLine = false;
+								}
+								//console.log(pLine);
+							},
+							() =>
+							{
+								console.log('LINE-BY-LINE FILE READING COMPLETE; GOOD DAY SIR.');
+								return fTestComplete();
+							},
+							(pError) =>
+							{
+								console.log(`Error reading file line-by-line: ${pError}`);
+							});
+						if (!tmpLineReader)
+						{
+							Expect(false).to.equal(true, 'The line reader was not initialized properly!')
+							return fTestComplete();
+						}
+					}
+				);
+				test
 				(
 					'Create, write, read and then delete a file.',
 					function(fTestComplete)
 					{
 						let testFable = new libFable();
-						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
-						let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+						let tmpFilePersistence = testFable.instantiateServiceProvider('FilePersistence');
+						let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 
 						let tmpLogFilePath = `/tmp/Fable-Test-${tmpDataGeneration.randomNumericString()}.log`;
 						testFable.log.info(`Writing test log file: [${tmpLogFilePath}]`);
@@ -62,7 +95,7 @@ suite
 
 						// Now delete the file
 						tmpFilePersistence.deleteFileSync(tmpLogFilePath);
-						
+
 						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(false);
 
 						return fTestComplete();
@@ -74,7 +107,7 @@ suite
 					function(fTestComplete)
 					{
 						let testFable = new libFable();
-						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
+						let tmpFilePersistence = testFable.instantiateServiceProvider('FilePersistence');
 
 						Expect(tmpFilePersistence.joinPath('/tmp/tests/../othertests/names/'))
 							.to.equal('/tmp/othertests/names');
@@ -88,8 +121,8 @@ suite
 					function(fTestComplete)
 					{
 						let testFable = new libFable();
-						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
-						let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+						let tmpFilePersistence = testFable.instantiateServiceProvider('FilePersistence');
+						let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 
 						let tmpFolderExtras = [];
 
@@ -121,8 +154,8 @@ suite
 					function(fTestComplete)
 					{
 						let testFable = new libFable();
-						let tmpFilePersistence = testFable.serviceManager.instantiateServiceProvider('FilePersistence');
-						let tmpDataGeneration = testFable.serviceManager.instantiateServiceProvider('DataGeneration');
+						let tmpFilePersistence = testFable.instantiateServiceProvider('FilePersistence');
+						let tmpDataGeneration = testFable.instantiateServiceProvider('DataGeneration');
 
 						let tmpLogFilePath = `/tmp/Fable-Test-${tmpDataGeneration.randomNumericString()}.log`;
 						testFable.log.info(`Writing test log file: [${tmpLogFilePath}]`);
@@ -139,7 +172,7 @@ suite
 
 						// Now delete the file
 						tmpFilePersistence.deleteFileSync(tmpLogFilePath);
-						
+
 						Expect(tmpFilePersistence.existsSync(tmpLogFilePath)).to.equal(false);
 
 						return fTestComplete();