fable 3.0.36 → 3.0.38

package/gulpfile-config.json

@@ -5,7 +5,7 @@
 
 	"LibraryOutputFolder": "./dist/",
 
-	"LibraryUniminifiedFileName": "fable.compatible.js",
+	"LibraryUniminifiedFileName": "fable.js",
 
-	"LibraryMinifiedFileName": "fable.compatible.min.js"
+	"LibraryMinifiedFileName": "fable.min.js"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.0.36",
+  "version": "3.0.38",
   "description": "An entity behavior management and API bundling library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -10,7 +10,8 @@
     "build": "./node_modules/.bin/gulp build",
     "build-compatible": "GULP_CUSTOM_BUILD_TARGET=compatible ./node_modules/.bin/gulp build",
     "docker-dev-build-image": "docker build ./ -f Dockerfile_LUXURYCode -t retold/fable:local",
-    "docker-dev-run": "docker run -it -d --name retold-fable-dev -p 30001:8080 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/fable:local"
+    "docker-dev-run": "docker run -it -d --name retold-fable-dev -p 30001:8080 -p 8086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/fable:local",
+    "docker-dev-shell": "docker exec -it retold-fable-dev /bin/bash"
   },
   "mocha": {
     "diff": true,

package/retold-harness/bookstore-serve-meadow-endpoint-apis-run.js

@@ -0,0 +1,6 @@
+const libServer = require('./bookstore-serve-meadow-endpoint-apis.js'); 
+let _Orator = libServer(
+	()=>
+	{
+		console.log('API service is started!');
+	});

package/{.config/retold-harness → retold-harness}/bookstore-serve-meadow-endpoint-apis.js

@@ -3,6 +3,7 @@
 */
 
 /**
+* @license MIT
 * @author <steven@velozo.com>
 */
 

package/{.config/retold-harness → retold-harness}/package.json

@@ -4,17 +4,19 @@
   "description": "Harness data import and server.",
   "main": "bookstore-serve-meadow-endpoints-apis.js",
   "scripts": {
+    "start": "node bookstore-serve-meadow-endpoint-apis-run.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "",
   "license": "MIT",
   "dependencies": {
     "async": "^3.2.4",
-    "fable": "^3.0.35",
+    "fable": "^3.0.37",
     "meadow": "^2.0.4",
-    "meadow-endpoints": "^3.0.7",
-    "mysql2": "^3.3.0",
+    "meadow-endpoints": "^4.0.2",
+    "mysql2": "^3.3.1",
     "orator": "^3.0.11",
+    "orator-serviceserver-restify": "^1.0.4",
     "papaparse": "^5.4.1"
   }
 }

package/source/Fable.js

@@ -9,15 +9,6 @@ const libFableLog = require('fable-log');
 
 const libFableServiceManager = require('./Fable-ServiceManager.js');
 
-// Default Services
-const libFableServiceEnvironmentData = require('./services/Fable-Service-EnvironmentData.js');
-const libFableServiceDataFormat = require('./services/Fable-Service-DataFormat.js');
-const libFableServiceMetaTemplate = require('./services/Fable-Service-MetaTemplate.js');
-const libFableServiceOperation = require('./services/Fable-Service-Operation.js');
-const libFableServiceRestClient = require('./services/Fable-Service-RestClient.js');
-const libFableServiceTemplate = require('./services/Fable-Service-Template.js');
-const libFableServiceUtility = require('./services/Fable-Service-Utility.js');
-
 class Fable
 {
 	constructor(pSettings)
@@ -51,14 +42,14 @@ class Fable
 		this.serviceManager.connectPreinitServiceProviderInstance(this._coreServices.SettingsManager);
 
 		// Initialize and instantiate the default baked-in Data Arithmatic service
-		this.serviceManager.addAndInstantiateServiceType('EnvironmentData', libFableServiceEnvironmentData);
-		this.serviceManager.addServiceType('Template', libFableServiceTemplate);
-		this.serviceManager.addServiceType('MetaTemplate', libFableServiceMetaTemplate);
-		this.serviceManager.addAndInstantiateServiceType('DataFormat', libFableServiceDataFormat);
-		this.serviceManager.addAndInstantiateServiceType('Utility', libFableServiceUtility);
-		this.serviceManager.addServiceType('Operation', libFableServiceOperation);
-		this.serviceManager.addServiceType('RestClient', libFableServiceRestClient);
-
+		this.serviceManager.addAndInstantiateServiceType('EnvironmentData', require('./services/Fable-Service-EnvironmentData.js'));
+		this.serviceManager.addServiceType('Template', require('./services/Fable-Service-Template.js'));
+		this.serviceManager.addServiceType('MetaTemplate', require('./services/Fable-Service-MetaTemplate.js'));
+		this.serviceManager.addAndInstantiateServiceType('DataFormat', require('./services/Fable-Service-DataFormat.js'));
+		this.serviceManager.addAndInstantiateServiceType('Utility', require('./services/Fable-Service-Utility.js'));
+		this.serviceManager.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
+		this.serviceManager.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));
+		this.serviceManager.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
 	}
 
 	get settings()

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

@@ -0,0 +1,199 @@
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+/**
+* Parsing CSVs.  Why?  Because it's a thing that needs to be done.
+*
+* 1. And the other node CSV parsers had issues with the really messy files we had.
+* 
+*
+* 2. None of the CSV parsers dealt with and multi-line quoted string columns
+*    which are apparently a-ok according to the official spec.
+* Plus a lot of them are asynchronous because apparently that's the best way to
+* do anything; unfortunately some files have a sequence issue with that.
+*
+* @class CSVParser
+*/
+class CSVParser extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'CSVParser';
+
+        this.Header = [];
+        this.HeaderFieldNames = [];
+
+        this.Delimiter = ',';
+        this.QuoteCharacter = '"';
+
+        this.CleanCharacters = ['\r'];
+
+        this.HeaderLineIndex = 0;
+        this.HasHeader = true;
+        this.HasSetHeader = false;
+        this.EmitHeader = false;
+
+        this.EmitJSON = true;
+
+        this.EscapedQuoteString = '"';
+
+        // Current Line Parsing State
+        this.CurrentLine = '';
+        this.CurrentRecord = [];
+
+        this.InQuote = false;
+        this.InEscapedQuote = false;
+
+        this.LinesParsed = 0;
+        this.RowsEmitted = 0;
+    }
+
+    marshalRowToJSON(pRowArray)
+    {
+        if (!Array.isArray(pRowArray))
+        {
+            return false;
+        }
+
+        for (let i = this.HeaderFieldNames.length; i < pRowArray.length; i++)
+        {
+            this.HeaderFieldNames[i] = `${i}`;
+        }
+
+        let tmpObject = {};
+
+        for (let i = 0; i < pRowArray.length; i++)
+        {
+            tmpObject[this.HeaderFieldNames[i]] = pRowArray[i];
+        }
+
+        return tmpObject;
+    }
+
+    // Set the header data, for use in marshalling to JSON.
+    setHeader (pHeaderArray)
+    {
+        this.Header = pHeaderArray;
+
+        for (let i = 0; i < this.Header.length; i++)
+        {
+            if (typeof(this.Header[i]) == 'undefined')
+            {
+                this.HeaderFieldNames[i] = `${i}`;
+            }
+            else
+            {
+                this.HeaderFieldNames[i] = this.Header[i].toString();
+            }
+        }
+    }
+
+    resetRowState()
+    {
+        this.CurrentRecord = [];
+    }
+
+    pushLine()
+    {
+        for (let i = 0; i < this.CleanCharacters.length; i++)
+        {
+            this.CurrentLine = this.CurrentLine.replace(this.CleanCharacters[i],'');
+        }
+        this.CurrentRecord.push(this.CurrentLine);
+        this.CurrentLine = '';
+    }
+
+    emitRow(pFormatAsJSON)
+    {
+        let tmpFormatAsJSON = (typeof(pFormatAsJSON) == 'undefined') ? this.EmitJSON : pFormatAsJSON;
+
+        this.RowsEmitted++;
+        let tmpCompletedRecord = this.CurrentRecord;
+        this.CurrentRecord = [];
+
+        if (tmpFormatAsJSON)
+        {
+            return this.marshalRowToJSON(tmpCompletedRecord);
+        }
+        else
+        {
+            return tmpCompletedRecord;
+        }
+    }
+
+    parseCSVLine (pLineString)
+    {
+        this.LinesParsed++;
+
+        for (let i = 0; i < pLineString.length; i++)
+        {
+            if ((!this.InQuote) && (pLineString[i] == this.Delimiter))
+            {
+                this.pushLine();
+            }
+            else if (pLineString[i] == this.QuoteCharacter)
+            {
+                // If we are in the second part of an escaped quote, ignore it.
+                if (this.InEscapedQuote)
+                {
+                    this.InEscapedQuote = false;
+                }
+                // If we aren't in a quote, enter quote
+                else if (!this.InQuote)
+                {
+                    this.InQuote = true;
+                }
+                // We are in a quote, so peek forward to see if this is an "escaped" quote pair
+                else if ((i < pLineString.length) && (pLineString[i+1] == this.QuoteCharacter))
+                {
+                    this.CurrentLine += this.EscapedQuoteString;
+                    this.InEscapedQuote = true;
+                }
+                // We are in a quote, this isn't an "escaped" quote pair, so go out of quote mode
+                else
+                {
+                    this.InQuote = false;
+                }
+            }
+            else
+            {
+                this.CurrentLine += pLineString[i];
+            }
+        }
+
+        // See if we are in a multiline quoted entry -- if not, emit the row.
+        if (!this.InQuote)
+        {
+            // Push the last remaining column from the buffer to the current line.
+            this.pushLine();
+
+            // Check to see if there is a header -- and if so, if this is the header row
+            if (this.HasHeader && !this.HasSetHeader && (this.RowsEmitted == this.HeaderLineIndex))
+            {
+                this.HasSetHeader = true;
+                // Override the format as json bit
+                this.setHeader(this.emitRow(false));
+
+                // No matter what, formatting this as JSON is silly and we don't want to go there anyway.
+                if (this.EmitHeader)
+                {
+                    return this.Header;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                return this.emitRow();
+            }
+        }
+        else
+        {
+            return false;
+        }
+    };
+}
+
+module.exports = CSVParser;

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

@@ -1,6 +1,3 @@
-/**
-*/
-
 const libFableServiceProviderBase = require('fable-serviceproviderbase');
 /**
 * Data Formatting and Translation Functions

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

@@ -19,64 +19,88 @@ class FableServiceRestClient extends libFableServiceBase
 		this.serviceType = 'RestClient';
 	}
 
-	getJSON(pOptionsOrURL, fCallback)
+	executeChunkedRequest(pOptions, fCallback)
 	{
-		return this.getRaw(pOptionsOrURL, 
-			(pError, pResponse, pResult) =>
+		pOptions.RequestStartTime = this.fable.log.getTimeStamp();
+
+		if (this.TraceLog)
+		{
+			this.fable.log.debug(`Beginning ${pOptions.method} request to ${pOptions.url} at ${pOptions.RequestStartTime}`);
+		}
+
+		return libSimpleGet(pOptions,
+			(pError, pResponse)=>
 			{
 				if (pError)
 				{
-					return fCallback(pError, pResponse, pResult);
+					return fCallback(pError, pResponse);
 				}
 
-				if (pResponse.statusCode != 200)
+				if (this.TraceLog)
 				{
-					return fCallback(new Error(`Invalid status code ${pResponse.statusCode}`), pResponse, pResult);
+					let tmpConnectTime = this.fable.log.getTimeStamp();
+					this.fable.log.debug(`--> ${pOptions.method} connected in ${this.dataFormat.formatTimeDelta(pOptions.RequestStartTime, tmpConnectTime)}ms code ${pResponse.statusCode}`);
 				}
 
-				return fCallback(pError, pResponse, JSON.parse(pResult));
+				let tmpData = '';
+
+				pResponse.on('data', (pChunk) =>
+					{
+						// For JSON, the chunk is the serialized object.
+						if (this.TraceLog)
+						{
+							let tmpChunkTime = this.fable.log.getTimeStamp();
+							this.fable.log.debug(`--> ${pOptions.method} data chunk size ${pChunk.length}b received in ${this.dataFormat.formatTimeDelta(pOptions.RequestStartTime, tmpChunkTime)}ms`);
+						}
+						tmpData += pChunk;
+					});
+
+				pResponse.on('end', ()=>
+					{
+						if (this.TraceLog)
+						{
+							let tmpCompletionTime = this.fable.log.getTimeStamp();
+							this.fable.log.debug(`==> ${pOptions.method} completed data size ${tmpData.length}b received in ${this.dataFormat.formatTimeDelta(pOptions.RequestStartTime, tmpCompletionTime)}ms`);
+						}
+						return fCallback(pError, pResponse, tmpData);
+					});
 			});
 	}
 
-	getRaw(pOptionsOrURL, fCallback)
+	executeJSONRequest(pOptions, fCallback)
 	{
-		let tmpRequestOptions = (typeof(pOptions) == 'object') ? pOptions : {};
-		if (typeof(pOptionsOrURL) == 'string')
-		{
-			tmpRequestOptions.url = pOptionsOrURL;
-		}
+		pOptions.json = true;
+
+		pOptions.RequestStartTime = this.fable.log.getTimeStamp();
 
-		let tmpRequestStartTime = this.fable.log.getTimeStamp();
 		if (this.TraceLog)
 		{
-			let tmpConnectTime = this.fable.log.getTimeStamp();
-			this.fable.log.debug(`Beginning GET request to ${tmpRequestOptions.url} at ${tmpRequestStartTime}`);
+			this.fable.log.debug(`Beginning ${pOptions.method} JSON request to ${pOptions.url} at ${pOptions.RequestStartTime}`);
 		}
 
-		libSimpleGet.get(tmpRequestOptions,
+		return libSimpleGet(pOptions,
 			(pError, pResponse)=>
 			{
 				if (pError)
 				{
-					return fCallback(pError, pResponse, tmpRequestOptions);
+					return fCallback(pError, pResponse);
 				}
 
 				if (this.TraceLog)
 				{
 					let tmpConnectTime = this.fable.log.getTimeStamp();
-					this.fable.log.debug(`--> GET connected in ${this.dataFormat.formatTimeDelta(tmpRequestStartTime, tmpConnectTime)}ms code ${pResponse.statusCode}`);
+					this.fable.log.debug(`--> JSON ${pOptions.method} connected in ${this.dataFormat.formatTimeDelta(pOptions.RequestStartTime, tmpConnectTime)}ms code ${pResponse.statusCode}`);
 				}
 
-				let tmpData = '';
-
-				pResponse.on('data', (pChunk)=>
+				pResponse.on('data', (pChunk) =>
 					{
 						if (this.TraceLog)
 						{
 							let tmpChunkTime = this.fable.log.getTimeStamp();
-							this.fable.log.debug(`--> GET data chunk size ${pChunk.length}b received in ${this.dataFormat.formatTimeDelta(tmpRequestStartTime, tmpChunkTime)}ms`);
+							this.fable.log.debug(`--> JSON ${pOptions.method} data chunk size ${pChunk.length}b received in ${this.dataFormat.formatTimeDelta(pOptions.RequestStartTime, tmpChunkTime)}ms`);
 						}
-						tmpData += pChunk;
+						// In a JSON request, the chunk is the serialized method.
+						return fCallback(pError, pResponse, JSON.parse(pChunk));
 					});
 
 				pResponse.on('end', ()=>
@@ -84,12 +108,92 @@ class FableServiceRestClient extends libFableServiceBase
 						if (this.TraceLog)
 						{
 							let tmpCompletionTime = this.fable.log.getTimeStamp();
-							this.fable.log.debug(`==> GET completed data size ${tmpData.length}b received in ${this.dataFormat.formatTimeDelta(tmpRequestStartTime, tmpCompletionTime)}ms`);
+							this.fable.log.debug(`==> JSON ${pOptions.method} completed - received in ${this.dataFormat.formatTimeDelta(pOptions.RequestStartTime, tmpCompletionTime)}ms`);
 						}
-						return fCallback(pError, pResponse, tmpData);
 					});
 			});
 	}
+
+	getJSON(pOptionsOrURL, fCallback)
+	{
+		let tmpRequestOptions = (typeof(pOptions) == 'object') ? pOptions : {};
+		if (typeof(pOptionsOrURL) == 'string')
+		{
+			tmpRequestOptions.url = pOptionsOrURL;
+		}
+
+		tmpRequestOptions.method = 'GET';
+
+		return this.executeJSONRequest(tmpRequestOptions, fCallback);
+	}
+
+	putJSON(pOptions, fCallback)
+	{
+		if (typeof(pOptions.body) != 'object')
+		{
+			return fCallback(new Error(`PUT JSON Error Invalid options object`));
+		}
+
+		pOptions.method = 'PUT';
+
+		return this.executeJSONRequest(pOptions, fCallback);
+	}
+
+	postJSON(pOptions, fCallback)
+	{
+		if (typeof(pOptions.body) != 'object')
+		{
+			return fCallback(new Error(`POST JSON Error Invalid options object`));
+		}
+
+		pOptions.method = 'POST';
+
+		return this.executeJSONRequest(pOptions, fCallback);
+	}
+
+	patchJSON(pOptions, fCallback)
+	{
+		if (typeof(pOptions.body) != 'object')
+		{
+			return fCallback(new Error(`PATCH JSON Error Invalid options object`));
+		}
+
+		pOptions.method = 'PATCH';
+
+		return this.executeJSONRequest(pOptions, fCallback);
+	}
+
+	headJSON(pOptions, fCallback)
+	{
+		if (typeof(pOptions.body) != 'object')
+		{
+			return fCallback(new Error(`HEAD JSON Error Invalid options object`));
+		}
+
+		pOptions.method = 'HEAD';
+
+		return this.executeJSONRequest(pOptions, fCallback);
+	}
+	
+	delJSON(pOptions, fCallback)
+	{
+		pOptions.method = 'DELETE';
+
+		return this.executeJSONRequest(pOptions, fCallback);
+	}
+
+	getRawText(pOptionsOrURL, fCallback)
+	{
+		let tmpRequestOptions = (typeof(pOptions) == 'object') ? pOptions : {};
+		if (typeof(pOptionsOrURL) == 'string')
+		{
+			tmpRequestOptions.url = pOptionsOrURL;
+		}
+
+		tmpRequestOptions.method = 'GET';
+
+		return this.executeChunkedRequest(tmpRequestOptions, fCallback);
+	}
 }
 
 module.exports = FableServiceRestClient;

package/test/CSVParser_tests.js

@@ -0,0 +1,66 @@
+/**
+* Unit tests for Fable
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+const libFS = require('fs');
+const libReadline = require('readline');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'CSV Parser',
+	function()
+	{
+		suite
+		(
+			'Parse CSV',
+			function()
+			{
+				test
+				(
+					'Pull CSV Data',
+					function(fDone)
+					{
+						let testFable = new libFable();
+						let tmpCSVParser = testFable.serviceManager.instantiateServiceProvider('CSVParser', {Name: 'Big Complex Integration Operation'}, 'CSV Parser-123');
+						let tmpRecords = [];
+
+						const tmpReadline = libReadline.createInterface(
+						{
+							input: libFS.createReadStream(`${__dirname}/data/books.csv`),
+							crlfDelay: Infinity
+						});
+
+						tmpReadline.on('line', 
+							(pLine) =>
+							{
+								let tmpRecord = tmpCSVParser.parseCSVLine(pLine);
+								if (tmpRecord)
+								{
+									tmpRecords.push(tmpRecord);
+								}
+							});
+
+						tmpReadline.on('close',
+							() =>
+							{
+								console.log(`Readline closed... testing import!`);
+								Expect(tmpRecords.length).to.equal(10000);
+								Expect(tmpRecords[0].authors).to.equal('Suzanne Collins');
+								return fDone();
+							});
+
+					}
+				);
+			}
+		);
+	}
+);

package/test/RestClient_test.js

@@ -38,16 +38,82 @@ suite
                         let tmpRestClient = testFable.serviceManager.instantiateServiceProvider('RestClient', {TraceLog: true}, 'RestClient-99');
 
 						// Download the wiktionary entry for dog!
-						tmpRestClient.getJSON('https://en.wiktionary.org/w/api.php?action=parse&prop=wikitext&format=json&page=dog',
+						tmpRestClient.getJSON('http://localhost:8086/1.0/Author/1',
 							(pError, pResponse, pBody)=>
 							{
 								Expect(pBody).to.be.an('object');
-								Expect(pBody.hasOwnProperty('parse')).to.equal(true);
-								Expect(pBody.parse.title).to.equal('dog');
+								Expect(pBody.hasOwnProperty('Name')).to.equal(true);
+								Expect(pBody.Name).to.equal('Suzanne Collins');
 								fTestComplete();
 							});
 					}
 				);
+				test
+				(
+					'Perform a POST request.',
+					function(fTestComplete)
+					{
+						let testFable = new libFable();
+						// Instantiate the RestClient Service Provider
+                        let tmpRestClient = testFable.serviceManager.instantiateServiceProvider('RestClient', {TraceLog: true}, 'RestClient-99');
+
+						// Download the wiktionary entry for dog!
+						tmpRestClient.postJSON({url: 'http://localhost:8086/1.0/Author', body:{Name:'Test Author'}},
+							(pError, pResponse, pBody)=>
+							{
+								Expect(pBody).to.be.an('object');
+								Expect(pBody.hasOwnProperty('Name')).to.equal(true);
+								Expect(pBody.Name).to.equal('Test Author');
+								fTestComplete();
+							});
+					}
+				);
+				test
+				(
+					'Perform a PUT request.',
+					function(fTestComplete)
+					{
+						let testFable = new libFable();
+						// Instantiate the RestClient Service Provider
+                        let tmpRestClient = testFable.serviceManager.instantiateServiceProvider('RestClient', {TraceLog: true}, 'RestClient-99');
+
+						// Download the wiktionary entry for dog!
+						tmpRestClient.putJSON({url: 'http://localhost:8086/1.0/Author/Upsert', body:{GUIDAuthor:'TestAuthor', Name:'Test Author 2'}},
+							(pError, pResponse, pBody)=>
+							{
+								Expect(pBody).to.be.an('object');
+								Expect(pBody.hasOwnProperty('Name')).to.equal(true);
+								Expect(pBody.Name).to.equal('Test Author 2');
+								fTestComplete();
+							});
+					}
+				);
+				test
+				(
+					'Perform an UPSERT request then a DELETE.',
+					function(fTestComplete)
+					{
+						let testFable = new libFable();
+						// Instantiate the RestClient Service Provider
+                        let tmpRestClient = testFable.serviceManager.instantiateServiceProvider('RestClient', {TraceLog: true}, 'RestClient-99');
+
+						// Download the wiktionary entry for dog!
+						tmpRestClient.putJSON({url: 'http://localhost:8086/1.0/Author/Upsert', body:{Name:'Test Author 2 DELETE'}},
+							(pError, pResponse, pBody)=>
+							{
+								Expect(pBody).to.be.an('object');
+								Expect(pBody.hasOwnProperty('Name')).to.equal(true);
+								Expect(pBody.Name).to.equal('Test Author 2 DELETE');
+								tmpRestClient.delJSON({url: `http://localhost:8086/1.0/Author/${pBody.IDAuthor}`},
+								(pDeleteError, pDeleteResponse, pDeleteBody) =>
+								{
+									Expect(pDeleteBody.Count)
+										.to.equal(1);
+									fTestComplete();
+								});
+							});
+					}
+				);
 			}
 		);
 	}