fable 3.1.71 → 3.1.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.1.71",
+  "version": "3.1.72",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -52,7 +52,7 @@
   "homepage": "https://github.com/stevenvelozo/fable",
   "devDependencies": {
     "pict-docuserve": "^0.1.5",
-    "quackage": "^1.1.2"
+    "quackage": "^1.2.3"
   },
   "dependencies": {
     "async.eachlimit": "^0.5.2",
@@ -65,7 +65,7 @@
     "fable-log": "^3.0.18",
     "fable-serviceproviderbase": "^3.0.19",
     "fable-settings": "^3.0.16",
-    "fable-uuid": "^3.0.13",
+    "fable-uuid": "^3.0.14",
     "manyfest": "^1.0.49",
     "simple-get": "^4.0.1"
   }

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

@@ -90,13 +90,20 @@ class FableServiceRestClient extends libFableServiceBase
 
 		this.prepareRequestOptions = (pOptions) =>
 		{
-			if (typeof pOptions.url === 'string' && pOptions.url.startsWith('http:'))
+			// Mirror simple-get's protocol decision exactly: it routes through
+			// the https module if and only if the parsed URL protocol is
+			// exactly 'https:'. Everything else — http: URLs, relative URLs
+			// (which simple-get treats as no-host http requests), and option
+			// objects with no .url at all — goes through the http module.
+			// Stamping an httpsAgent on an http request makes Node throw
+			// ERR_INVALID_PROTOCOL when http.request validates agent.protocol.
+			if (typeof pOptions.url === 'string' && pOptions.url.startsWith('https:'))
 			{
-				pOptions.agent = this.httpAgent;
+				pOptions.agent = this.httpsAgent;
 			}
 			else
 			{
-				pOptions.agent = this.httpsAgent;
+				pOptions.agent = this.httpAgent;
 			}
 			return tmpPreviousPrepareRequestOptions(pOptions);
 		};
@@ -148,6 +155,196 @@ class FableServiceRestClient extends libFableServiceBase
 		return this.prepareRequestOptions(tmpOptions);
 	}
 
+	/**
+	 * Extract the hostname from a URL string. Returns null for relative URLs
+	 * or anything else that doesn't parse cleanly.
+	 *
+	 * @private
+	 * @param {string} pUrl
+	 * @return {string|null}
+	 */
+	_parseHostname(pUrl)
+	{
+		if (typeof pUrl !== 'string')
+		{
+			return null;
+		}
+		try
+		{
+			return new URL(pUrl).hostname || null;
+		}
+		catch (e)
+		{
+			return null;
+		}
+	}
+
+	/**
+	 * Resolve a Location header against the URL of the request that produced
+	 * it. Handles absolute Locations (returned as-is) and RFC 7231-compliant
+	 * relative Locations (resolved against the current URL).
+	 *
+	 * @private
+	 * @param {string} pCurrentURL - The URL of the request that produced the redirect.
+	 * @param {string} pLocation - The Location header value.
+	 * @return {string}
+	 */
+	_resolveRedirectURL(pCurrentURL, pLocation)
+	{
+		if (typeof pLocation !== 'string' || pLocation.length === 0)
+		{
+			return pLocation;
+		}
+		try
+		{
+			return new URL(pLocation, pCurrentURL).toString();
+		}
+		catch (e)
+		{
+			// Either pCurrentURL is itself relative or pLocation is malformed.
+			// Fall back to passing it through verbatim — simple-get's parser
+			// will give the next hop a final say.
+			return pLocation;
+		}
+	}
+
+	/**
+	 * Build the options object for the next hop of a redirect chain. Applies
+	 * the same hop-rewrite rules simple-get does, plus an RFC-correct relative
+	 * Location resolution that simple-get itself doesn't do:
+	 *   - Resolve the Location against the current URL (absolute or relative).
+	 *   - Strip simple-get's URL-derived state (protocol/hostname/port/path/auth)
+	 *     so the next hop re-parses the URL cleanly.
+	 *   - Drop the host header (re-derived from the new URL by simple-get).
+	 *   - Cross-origin: drop cookie + authorization to prevent leak.
+	 *   - 301/302 + POST: switch to GET, drop body and content headers.
+	 *
+	 * @private
+	 * @param {Object} pOptions - The options used for the previous hop (post-simple-get mutation).
+	 * @param {import('http').IncomingMessage} pResponse - The 3xx response.
+	 * @param {string|undefined} pOriginalURL - The URL of the previous hop, captured before simple-get deleted it.
+	 * @param {string|null} pOriginalHost - The hostname of the previous hop, for cross-origin detection.
+	 * @return {Object}
+	 */
+	_buildRedirectedOptions(pOptions, pResponse, pOriginalURL, pOriginalHost)
+	{
+		const tmpNew = Object.assign({}, pOptions);
+		tmpNew.url = this._resolveRedirectURL(pOriginalURL, pResponse.headers.location);
+
+		// Strip simple-get's own URL-derived fields so the next call re-parses cleanly.
+		delete tmpNew.protocol;
+		delete tmpNew.hostname;
+		delete tmpNew.port;
+		delete tmpNew.path;
+		delete tmpNew.auth;
+
+		// We set followRedirects=false on the previous hop to disable
+		// simple-get's auto-follow; that's our own internal flag, not caller
+		// intent. Drop it so the recursive _executeWithRedirects entry treats
+		// the next hop as another redirect-following call.
+		delete tmpNew.followRedirects;
+
+		// Headers — clone (don't mutate the caller's) and prune.
+		if (tmpNew.headers)
+		{
+			tmpNew.headers = Object.assign({}, tmpNew.headers);
+			delete tmpNew.headers.host;
+		}
+
+		// Cross-origin redirect: drop cookie and authorization to prevent leak (matches simple-get #73).
+		const tmpRedirectHost = this._parseHostname(tmpNew.url);
+		if (tmpRedirectHost !== null && tmpRedirectHost !== pOriginalHost && tmpNew.headers)
+		{
+			delete tmpNew.headers.cookie;
+			delete tmpNew.headers.authorization;
+		}
+
+		// 301/302 + POST → GET (matches simple-get #35 and RFC 7231 §6.4.2/6.4.3).
+		// Body and content headers come off; 307/308 preserve method/body so we leave them alone.
+		if (tmpNew.method === 'POST' && (pResponse.statusCode === 301 || pResponse.statusCode === 302))
+		{
+			tmpNew.method = 'GET';
+			if (tmpNew.headers)
+			{
+				delete tmpNew.headers['content-length'];
+				delete tmpNew.headers['content-type'];
+			}
+			delete tmpNew.body;
+			delete tmpNew.form;
+		}
+
+		return tmpNew;
+	}
+
+	/**
+	 * Dispatch a request via simple-get, transparently following 3xx redirects
+	 * until a non-redirect response or hard error.
+	 *
+	 * Why we drive the loop ourselves: simple-get's own redirect path
+	 * (index.js lines 50-69) recurses with the original opts.agent intact, so
+	 * an http→https redirect ends up calling https.request with an httpAgent
+	 * (or vice versa) and Node throws ERR_INVALID_PROTOCOL synchronously.
+	 * By disabling simple-get's auto-follow and running prepareRequestOptions
+	 * on each hop, the agent gets re-picked to match the new URL's protocol.
+	 *
+	 * Caller can opt out by setting `followRedirects: false` on options
+	 * (matches simple-get's contract) — in that case we hand the 3xx straight
+	 * back without following.
+	 *
+	 * @private
+	 * @param {Object} pOptions - Already passed through preRequest on the first call; on recursion, already passed through prepareRequestOptions.
+	 * @param {(err?: Error, res?: import('http').IncomingMessage) => void} fCallback
+	 */
+	_executeWithRedirects(pOptions, fCallback)
+	{
+		if (pOptions.followRedirects === false)
+		{
+			return libSimpleGet(pOptions, fCallback);
+		}
+
+		// Disable simple-get's own redirect loop — we own it from here.
+		pOptions.followRedirects = false;
+		const tmpOriginalURL = pOptions.url;
+		const tmpOriginalHost = this._parseHostname(tmpOriginalURL);
+
+		return libSimpleGet(pOptions, (pError, pResponse) =>
+		{
+			if (pError)
+			{
+				return fCallback(pError, pResponse);
+			}
+
+			if (pResponse.statusCode < 300 || pResponse.statusCode >= 400 || !pResponse.headers.location)
+			{
+				return fCallback(null, pResponse);
+			}
+
+			// 3xx with Location — drain and follow.
+			pResponse.resume();
+
+			let tmpRedirectsRemaining = (typeof pOptions.maxRedirects === 'number') ? pOptions.maxRedirects : 10;
+			if (tmpRedirectsRemaining <= 0)
+			{
+				return fCallback(new Error('too many redirects'));
+			}
+
+			const tmpNextOptions = this._buildRedirectedOptions(pOptions, pResponse, tmpOriginalURL, tmpOriginalHost);
+			tmpNextOptions.maxRedirects = tmpRedirectsRemaining - 1;
+
+			// Re-run the agent picker so the next hop's agent matches the
+			// (possibly different) protocol of the redirect target. We do
+			// NOT re-run preRequest in full — RestClientURLPrefix and
+			// prepareCookies are first-call-only.
+			const tmpPreparedNext = this.prepareRequestOptions(tmpNextOptions);
+
+			if (this.TraceLog)
+			{
+				this.fable.log.debug(`--> redirect ${pResponse.statusCode} to ${tmpPreparedNext.url}`);
+			}
+			return this._executeWithRedirects(tmpPreparedNext, fCallback);
+		});
+	}
+
 	executeChunkedRequest(pOptions, fCallback)
 	{
 		let tmpOptions = this.preRequest(pOptions);
@@ -159,7 +356,7 @@ class FableServiceRestClient extends libFableServiceBase
 			this.fable.log.debug(`Beginning ${tmpOptions.method} request to ${tmpOptions.url} at ${tmpOptions.RequestStartTime}`);
 		}
 
-		return libSimpleGet(tmpOptions,
+		return this._executeWithRedirects(tmpOptions,
 			(pError, pResponse)=>
 			{
 				if (pError)
@@ -212,7 +409,7 @@ class FableServiceRestClient extends libFableServiceBase
 		tmpOptions.json = false;
 		tmpOptions.encoding = null;
 
-		return libSimpleGet(tmpOptions,
+		return this._executeWithRedirects(tmpOptions,
 			(pError, pResponse)=>
 			{
 				if (pError)
@@ -283,7 +480,7 @@ class FableServiceRestClient extends libFableServiceBase
 			this.fable.log.debug(`Beginning ${tmpOptions.method} JSON request to ${tmpOptions.url} at ${tmpOptions.RequestStartTime}`);
 		}
 
-		return libSimpleGet(tmpOptions,
+		return this._executeWithRedirects(tmpOptions,
 			(pError, pResponse)=>
 			{
 				if (pError)
@@ -461,7 +658,7 @@ class FableServiceRestClient extends libFableServiceBase
 
 		tmpOptions.json = false;
 
-		return libSimpleGet(tmpOptions,
+		return this._executeWithRedirects(tmpOptions,
 			(pError, pResponse) =>
 			{
 				if (pError)

package/test/RestClient_test.js

@@ -278,6 +278,73 @@ suite
 										Expect(tmpHttp.agent).to.equal(tmpRestClient.httpAgent);
 									}
 								);
+							test
+								(
+									'Selects the http agent for relative URLs and option objects without a URL.',
+									function ()
+									{
+										// simple-get's protocol decision is `opts.protocol === 'https:'
+										// ? https : http`, so a URL with no protocol — including a
+										// relative path or a pre-parsed options object — routes through
+										// the http module. The agent we stamp on must match, otherwise
+										// Node throws ERR_INVALID_PROTOCOL on dispatch.
+										let testFable = new libFable();
+										let tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-AgentInject-Relative');
+
+										let tmpRelative = tmpRestClient.prepareRequestOptions({ url: '/1.0/Users/Count' });
+										let tmpNoUrl = tmpRestClient.prepareRequestOptions({ hostname: 'localhost', port: 8086, path: '/1.0/Users' });
+
+										Expect(tmpRelative.agent).to.equal(tmpRestClient.httpAgent);
+										Expect(tmpNoUrl.agent).to.equal(tmpRestClient.httpAgent);
+									}
+								);
+							test
+								(
+									'A relative URL is dispatched without throwing ERR_INVALID_PROTOCOL.',
+									function (fTestComplete)
+									{
+										// End-to-end regression: before the fix, fable stamped the
+										// httpsAgent on relative URLs while simple-get routed them
+										// through http.request, which made Node throw synchronously.
+										// We point fable at a real http server via RestClientURLPrefix
+										// so the relative URL becomes resolvable, and assert that the
+										// request completes (rather than throwing on dispatch).
+										var tmpServer = libHTTP.createServer(function (pReq, pRes)
+										{
+											pRes.writeHead(200, { 'Content-Type': 'application/json' });
+											pRes.end(JSON.stringify({ Path: pReq.url }));
+										});
+
+										tmpServer.listen(0, function ()
+										{
+											var tmpPort = tmpServer.address().port;
+											var testFable = new libFable({ RestClientURLPrefix: 'http://localhost:' + tmpPort });
+											var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-RelativeURL-Dispatch');
+
+											var tmpOriginalPrepare = tmpRestClient.prepareRequestOptions;
+											var tmpCapturedAgent = null;
+											tmpRestClient.prepareRequestOptions = function (pOptions)
+											{
+												let tmpResult = tmpOriginalPrepare(pOptions);
+												if (tmpCapturedAgent === null)
+												{
+													tmpCapturedAgent = tmpResult.agent;
+												}
+												return tmpResult;
+											};
+
+											tmpRestClient.getJSON('/relative/path',
+												function (pError, pResponse, pBody)
+												{
+													Expect(pError).to.equal(null);
+													Expect(tmpCapturedAgent).to.equal(tmpRestClient.httpAgent);
+													Expect(pBody.Path).to.equal('/relative/path');
+													tmpServer.close();
+													fTestComplete();
+												});
+										});
+									}
+								);
 							test
 								(
 									'Chains with previously set prepareRequestOptions.',
@@ -479,6 +546,281 @@ suite
 						}
 					);
 
+				suite
+					(
+						'Redirect Following',
+						function ()
+						{
+							test
+								(
+									'Follows a basic 301 redirect end-to-end.',
+									function (fTestComplete)
+									{
+										// Single server: /start returns 301 to /dest, /dest returns 200 + JSON.
+										var tmpServer = libHTTP.createServer(function (pReq, pRes)
+										{
+											if (pReq.url === '/start')
+											{
+												pRes.writeHead(301, { Location: '/dest' });
+												pRes.end();
+												return;
+											}
+											pRes.writeHead(200, { 'Content-Type': 'application/json' });
+											pRes.end(JSON.stringify({ Reached: pReq.url }));
+										});
+										tmpServer.listen(0, function ()
+										{
+											var tmpPort = tmpServer.address().port;
+											var testFable = new libFable();
+											var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-Redirect-Basic');
+											tmpRestClient.getJSON('http://localhost:' + tmpPort + '/start',
+												function (pError, pResponse, pBody)
+												{
+													Expect(pError).to.equal(null);
+													Expect(pBody.Reached).to.equal('/dest');
+													tmpServer.close();
+													fTestComplete();
+												});
+										});
+									}
+								);
+							test
+								(
+									'Re-picks the agent on a protocol-changing redirect.',
+									function (fTestComplete)
+									{
+										// http server redirects to an https URL. We don't need the https
+										// destination to be reachable — we just need to verify that
+										// prepareRequestOptions runs again on the redirect target and
+										// stamps the httpsAgent on the second hop.
+										var tmpAssignedAgents = [];
+										var tmpServer = libHTTP.createServer(function (pReq, pRes)
+										{
+											pRes.writeHead(302, { Location: 'https://nowhere.invalid/x' });
+											pRes.end();
+										});
+										tmpServer.listen(0, function ()
+										{
+											var tmpPort = tmpServer.address().port;
+											var testFable = new libFable();
+											var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-Redirect-ProtoSwitch');
+
+											var tmpOriginalPrepare = tmpRestClient.prepareRequestOptions;
+											tmpRestClient.prepareRequestOptions = function (pOptions)
+											{
+												var tmpResult = tmpOriginalPrepare(pOptions);
+												tmpAssignedAgents.push({ url: tmpResult.url, agent: tmpResult.agent });
+												return tmpResult;
+											};
+
+											tmpRestClient.getJSON('http://localhost:' + tmpPort + '/start',
+												function (pError)
+												{
+													// The second hop will fail (DNS lookup of nowhere.invalid)
+													// but the agent re-pick must have already happened
+													// before that — and crucially, must NOT have thrown
+													// ERR_INVALID_PROTOCOL synchronously like the old code.
+													Expect(tmpAssignedAgents.length).to.be.at.least(2);
+													Expect(tmpAssignedAgents[0].agent).to.equal(tmpRestClient.httpAgent);
+													Expect(tmpAssignedAgents[1].agent).to.equal(tmpRestClient.httpsAgent);
+													Expect(tmpAssignedAgents[1].url).to.equal('https://nowhere.invalid/x');
+													tmpServer.close();
+													fTestComplete();
+												});
+										});
+									}
+								);
+							test
+								(
+									'Bails with "too many redirects" when the budget is exceeded.',
+									function (fTestComplete)
+									{
+										// Self-redirecting server. Cap at 3 hops so the test stays quick.
+										var tmpServer = libHTTP.createServer(function (pReq, pRes)
+										{
+											pRes.writeHead(302, { Location: pReq.url });
+											pRes.end();
+										});
+										tmpServer.listen(0, function ()
+										{
+											var tmpPort = tmpServer.address().port;
+											var testFable = new libFable();
+											var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-Redirect-Loop');
+											tmpRestClient.getJSON({ url: 'http://localhost:' + tmpPort + '/loop', maxRedirects: 3 },
+												function (pError)
+												{
+													Expect(pError).to.be.an.instanceof(Error);
+													Expect(pError.message).to.equal('too many redirects');
+													tmpServer.close();
+													fTestComplete();
+												});
+										});
+									}
+								);
+							test
+								(
+									'Drops cookie and authorization on cross-origin redirect.',
+									function (fTestComplete)
+									{
+										// Two servers on different ports. We use 127.0.0.1 vs localhost
+										// to make them count as different hostnames per
+										// _parseHostname's URL-string check.
+										var tmpReceivedAtA = null;
+										var tmpReceivedAtB = null;
+										var tmpServerB = libHTTP.createServer(function (pReq, pRes)
+										{
+											tmpReceivedAtB = pReq.headers;
+											pRes.writeHead(200, { 'Content-Type': 'application/json' });
+											pRes.end(JSON.stringify({ ok: true }));
+										});
+										tmpServerB.listen(0, function ()
+										{
+											var tmpPortB = tmpServerB.address().port;
+											var tmpServerA = libHTTP.createServer(function (pReq, pRes)
+											{
+												tmpReceivedAtA = pReq.headers;
+												pRes.writeHead(302, { Location: 'http://127.0.0.1:' + tmpPortB + '/dest' });
+												pRes.end();
+											});
+											tmpServerA.listen(0, function ()
+											{
+												var tmpPortA = tmpServerA.address().port;
+												var testFable = new libFable();
+												var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-Redirect-CrossOrigin');
+												tmpRestClient.getJSON({
+													url: 'http://localhost:' + tmpPortA + '/start',
+													headers: { cookie: 'session=abc', authorization: 'Bearer xyz' }
+												},
+												function (pError, pResponse, pBody)
+												{
+													Expect(pError).to.equal(null);
+													Expect(pBody.ok).to.equal(true);
+													Expect(tmpReceivedAtA.cookie).to.equal('session=abc');
+													Expect(tmpReceivedAtA.authorization).to.equal('Bearer xyz');
+													Expect(tmpReceivedAtB.cookie).to.equal(undefined);
+													Expect(tmpReceivedAtB.authorization).to.equal(undefined);
+													tmpServerA.close();
+													tmpServerB.close();
+													fTestComplete();
+												});
+											});
+										});
+									}
+								);
+							test
+								(
+									'Converts POST to GET on a 301/302 redirect and drops the body.',
+									function (fTestComplete)
+									{
+										var tmpDestRequest = null;
+										var tmpServer = libHTTP.createServer(function (pReq, pRes)
+										{
+											if (pReq.url === '/start')
+											{
+												pRes.writeHead(301, { Location: '/dest' });
+												pRes.end();
+												return;
+											}
+											tmpDestRequest = { method: pReq.method, headers: pReq.headers };
+											var tmpBody = '';
+											pReq.on('data', function (pChunk) { tmpBody += pChunk; });
+											pReq.on('end', function ()
+											{
+												tmpDestRequest.body = tmpBody;
+												pRes.writeHead(200, { 'Content-Type': 'application/json' });
+												pRes.end(JSON.stringify({ ok: true }));
+											});
+										});
+										tmpServer.listen(0, function ()
+										{
+											var tmpPort = tmpServer.address().port;
+											var testFable = new libFable();
+											var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-Redirect-PostToGet');
+											tmpRestClient.postJSON({ url: 'http://localhost:' + tmpPort + '/start', body: { foo: 'bar' } },
+												function (pError, pResponse, pBody)
+												{
+													Expect(pError).to.equal(null);
+													Expect(pBody.ok).to.equal(true);
+													Expect(tmpDestRequest.method).to.equal('GET');
+													Expect(tmpDestRequest.body).to.equal('');
+													Expect(tmpDestRequest.headers['content-type']).to.equal(undefined);
+													Expect(tmpDestRequest.headers['content-length']).to.equal(undefined);
+													tmpServer.close();
+													fTestComplete();
+												});
+										});
+									}
+								);
+							test
+								(
+									'Resolves a relative Location header against the current URL.',
+									function (fTestComplete)
+									{
+										// Server returns a relative Location ("dest" instead of "/dest").
+										// RFC 7231 allows this; the next hop's URL must be resolved
+										// against the URL that produced the redirect.
+										var tmpDestRequestURL = null;
+										var tmpServer = libHTTP.createServer(function (pReq, pRes)
+										{
+											if (pReq.url === '/section/start')
+											{
+												pRes.writeHead(302, { Location: 'dest' });
+												pRes.end();
+												return;
+											}
+											tmpDestRequestURL = pReq.url;
+											pRes.writeHead(200, { 'Content-Type': 'application/json' });
+											pRes.end(JSON.stringify({ ok: true }));
+										});
+										tmpServer.listen(0, function ()
+										{
+											var tmpPort = tmpServer.address().port;
+											var testFable = new libFable();
+											var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-Redirect-RelativeLocation');
+											tmpRestClient.getJSON('http://localhost:' + tmpPort + '/section/start',
+												function (pError, pResponse, pBody)
+												{
+													Expect(pError).to.equal(null);
+													Expect(pBody.ok).to.equal(true);
+													Expect(tmpDestRequestURL).to.equal('/section/dest');
+													tmpServer.close();
+													fTestComplete();
+												});
+										});
+									}
+								);
+							test
+								(
+									'Honors followRedirects: false by handing the 3xx straight back.',
+									function (fTestComplete)
+									{
+										// When the caller opts out, we shouldn't follow the redirect —
+										// the JSON parser will fail because the 3xx body is empty,
+										// which is the expected pre-fix behavior.
+										var tmpServer = libHTTP.createServer(function (pReq, pRes)
+										{
+											pRes.writeHead(302, { Location: '/dest' });
+											pRes.end();
+										});
+										tmpServer.listen(0, function ()
+										{
+											var tmpPort = tmpServer.address().port;
+											var testFable = new libFable();
+											var tmpRestClient = testFable.instantiateServiceProvider('RestClient', {}, 'RestClient-Redirect-OptOut');
+											tmpRestClient.getJSON({ url: 'http://localhost:' + tmpPort + '/start', followRedirects: false },
+												function (pError, pResponse)
+												{
+													Expect(pResponse.statusCode).to.equal(302);
+													Expect(pResponse.headers.location).to.equal('/dest');
+													tmpServer.close();
+													fTestComplete();
+												});
+										});
+									}
+								);
+						}
+					);
+
 				suite
 					(
 						'Error Handling',