soajs.controller 4.3.1 → 4.3.3

package/.github/workflows/ci.yml

@@ -6,9 +6,14 @@ on:
   pull_request:
     branches: [ master, develop ]
 
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: 'true'
+
 jobs:
   test:
     runs-on: ubuntu-latest
+    env:
+      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: 'true'
 
     services:
       mongodb:
@@ -18,10 +23,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v4.2.2
 
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v4.4.0
         with:
           node-version: '24'
 

package/.github/workflows/release.yml

@@ -6,9 +6,14 @@ on:
       - release
       - 'release/**'
 
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: 'true'
+
 jobs:
   test:
     runs-on: ubuntu-latest
+    env:
+      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: 'true'
 
     services:
       mongodb:
@@ -18,10 +23,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v4.2.2
 
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v4.4.0
         with:
           node-version: '24'
 
@@ -40,10 +45,12 @@ jobs:
   publish-docker:
     runs-on: ubuntu-latest
     needs: test
+    env:
+      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: 'true'
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v4.2.2
 
       - name: Extract version from package.json
         id: version
@@ -85,7 +92,7 @@ jobs:
         run: git push origin ${{ steps.version.outputs.PACKAGE_VERSION }} || true
 
       - name: Create GitHub Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ steps.version.outputs.PACKAGE_VERSION }}
           name: Release ${{ steps.version.outputs.PACKAGE_VERSION }}

package/lib/parseURL.js

@@ -8,7 +8,20 @@
  * found in the LICENSE file at the root of this repository
  */
 
-const url = require('url');
+/**
+ * Parse URL using WHATWG URL API and return object compatible with legacy url.parse()
+ * @param {string} urlString - URL string to parse
+ * @returns {Object} - Object with pathname, path, and query properties
+ */
+const parseURL = (urlString) => {
+	const urlObj = new URL(urlString, 'http://localhost');
+	const search = urlObj.search || '';
+	return {
+		pathname: urlObj.pathname,
+		path: urlObj.pathname + search,
+		query: Object.fromEntries(urlObj.searchParams)
+	};
+};
 
 
 module.exports = (uri, parsedUrl) => {
@@ -16,7 +29,7 @@ module.exports = (uri, parsedUrl) => {
 	let service_nv = serviceInfo[1];
 	let service_n = service_nv;
 	let service_v = null;
-	
+
 	//check if there is /v1 or v1.1 in the url
 	let matches = uri.match(/\/v[0-9]+(.[0-9]+)?\//);
 	if (matches && matches.length > 0) {
@@ -25,7 +38,7 @@ module.exports = (uri, parsedUrl) => {
 			service_v = hit.replace("v", '');
 			serviceInfo.splice(2, 1);
 			uri = uri.replace(matches[0], "/");
-			parsedUrl = url.parse(uri, true);
+			parsedUrl = parseURL(uri);
 		}
 	}
 	

package/mw/gotoService/redirectToService.js

@@ -12,6 +12,121 @@ const get = (p, o) => p.reduce((xs, x) => (xs && xs[x]) ? xs[x] : null, o);
 
 const { httpRequestLight, proxyRequestMonitor } = require("../../lib/request.js");
 
+// Monitor buffer for batch uploads
+let monitorBuffer = [];
+let monitorFlushTimer = null;
+let monitorFlushInProgress = false;
+let lastReqForFlush = null;
+
+/**
+ * Flush the monitor buffer to soamonitor
+ */
+function flushMonitorBuffer() {
+	if (monitorFlushInProgress || monitorBuffer.length === 0 || !lastReqForFlush) {
+		return;
+	}
+
+	monitorFlushInProgress = true;
+
+	// Clear timer if exists
+	if (monitorFlushTimer) {
+		clearTimeout(monitorFlushTimer);
+		monitorFlushTimer = null;
+	}
+
+	// Take current buffer and reset
+	let itemsToSend = monitorBuffer;
+	let req = lastReqForFlush;
+	monitorBuffer = [];
+
+	let soamonitor = "soamonitor";
+	let soamonitorVersion = "1";
+	let port = get(["registry", "services", "soamonitor", "port"], req.soajs) || "4050";
+	let api = "/monitor/items";  // Batch endpoint
+
+	req.soajs.awareness.getHost(soamonitor, soamonitorVersion, function (host) {
+		monitorFlushInProgress = false;
+
+		if (!host) {
+			req.soajs.log.debug('Monitor buffer flush: Unable to find host for ' + soamonitor);
+			// Put items back in buffer for retry
+			monitorBuffer = itemsToSend.concat(monitorBuffer);
+			return;
+		}
+
+		// Convert body/response to strings
+		itemsToSend.forEach(doc => {
+			if (doc.body) {
+				doc.body = doc.body.toString();
+			}
+			if (doc.response) {
+				doc.response = doc.response.toString();
+			}
+		});
+
+		let uri = "http://" + host + ":" + port + api;
+		let options = {
+			"method": "POST",
+			"uri": uri,
+			"data": { "items": itemsToSend },
+			"json": true
+		};
+
+		httpRequestLight(options)
+			.then((body) => {
+				if (body && !body.result) {
+					req.soajs.log.debug('Monitor buffer flush response:', body);
+				} else {
+					req.soajs.log.debug('Monitor buffer flushed: ' + itemsToSend.length + ' items');
+				}
+			})
+			.catch((error) => {
+				req.soajs.log.debug('Monitor buffer flush failed: ' + error.message);
+			});
+	});
+}
+
+/**
+ * Add item to monitor buffer and trigger flush if needed
+ * @param {Object} req - Request object
+ * @param {Object} doc - Monitor document to buffer
+ * @param {Object} monitor - Monitor configuration
+ */
+function bufferMonitorItem(req, doc, monitor) {
+	monitorBuffer.push(doc);
+	lastReqForFlush = req;
+
+	let bufferConfig = monitor.buffer || {};
+	let bufferTime = bufferConfig.time;
+	let bufferLimit = bufferConfig.limit;
+
+	// Check count threshold
+	if (bufferLimit && monitorBuffer.length >= bufferLimit) {
+		flushMonitorBuffer();
+		return;
+	}
+
+	// Start timer if not already running and time threshold is set
+	if (bufferTime && !monitorFlushTimer) {
+		monitorFlushTimer = setTimeout(() => {
+			monitorFlushTimer = null;
+			flushMonitorBuffer();
+		}, bufferTime);
+	}
+}
+
+// Graceful shutdown - flush remaining buffer
+process.on('SIGTERM', () => {
+	if (monitorBuffer.length > 0 && !monitorFlushInProgress) {
+		// Best-effort cleanup
+		monitorBuffer = [];
+		if (monitorFlushTimer) {
+			clearTimeout(monitorFlushTimer);
+			monitorFlushTimer = null;
+		}
+	}
+});
+
 module.exports = (configuration) => {
 
 	let core = configuration.core;
@@ -26,12 +141,21 @@ module.exports = (configuration) => {
 	 */
 	return (req, res) => {
 		preRedirect(req, res, core, function (obj) {
+			let monitor = get(["registry", "custom", "gateway", "value", "gotoService", "monitor"], req.soajs);
 			let log_monitor_triggered = false;
 			let log_monitor = (doc) => {
 				if (log_monitor_triggered) {
 					return;
 				}
 				log_monitor_triggered = true;
+
+				// Check if buffering is enabled
+				if (monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit)) {
+					bufferMonitorItem(req, doc, monitor);
+					return;
+				}
+
+				// Original immediate send logic (unchanged)
 				let soamonitor = "soamonitor";
 				let soamonitorVersion = "1";
 				let port = get(["registry", "services", "soamonitor", "port"], req.soajs);
@@ -72,8 +196,6 @@ module.exports = (configuration) => {
 					}
 				});
 			};
-
-			let monitor = get(["registry", "custom", "gateway", "value", "gotoService", "monitor"], req.soajs);
 			let monitoObj = {
 				"time": {}
 			};

package/mw/lastSeen/index.js

@@ -52,11 +52,12 @@ function getRouteRegExp(route) {
  * Check if the current request should trigger lastSeen
  * @param {Object} include - The include whitelist configuration
  * @param {string} serviceName - The current service name
- * @param {string} apiPath - The current API path
+ * @param {string} apiPath - The current API path (relative to service, e.g., "/active")
+ * @param {string} fullPath - The full API path (e.g., "/connectspaces/active")
  * @param {string} method - The HTTP method (GET, POST, etc.)
  * @returns {boolean} - true if lastSeen should be triggered
  */
-function shouldTriggerLastSeen(include, serviceName, apiPath, method) {
+function shouldTriggerLastSeen(include, serviceName, apiPath, fullPath, method) {
     // No include filter = trigger for all (backward compatible)
     if (!include) {
         return true;
@@ -74,9 +75,17 @@ function shouldTriggerLastSeen(include, serviceName, apiPath, method) {
         return true;
     }
 
-    // API-level match
+    // API-level match - check both relative path and full path for backward compatibility
     if (typeof serviceConfig === 'object' && serviceConfig.apis) {
-        return isApiMethodMatch(serviceConfig.apis, apiPath, method);
+        // Try relative path first (e.g., "/active")
+        if (apiPath && isApiMethodMatch(serviceConfig.apis, apiPath, method)) {
+            return true;
+        }
+        // Fallback to full path for backward compatibility (e.g., "/connectspaces/active")
+        if (fullPath && fullPath !== apiPath && isApiMethodMatch(serviceConfig.apis, fullPath, method)) {
+            return true;
+        }
+        return false;
     }
 
     return false;
@@ -150,11 +159,13 @@ module.exports = () => {
 
                 // Check include filter
                 let currentService = get(["soajs", "controller", "serviceParams", "name"], req);
-                let currentApi = get(["soajs", "controller", "serviceParams", "parsedUrl", "pathname"], req);
+                // Get both relative path (e.g., "/active") and full path (e.g., "/connectspaces/active")
+                let currentApi = get(["soajs", "controller", "serviceParams", "path"], req);
+                let fullPath = get(["soajs", "controller", "serviceParams", "parsedUrl", "pathname"], req);
                 let currentMethod = req.method;
 
-                if (!shouldTriggerLastSeen(lastSeen.include, currentService, currentApi, currentMethod)) {
-                    req.soajs.log.debug("lastSeen skipped for [" + currentService + " " + currentMethod + " " + currentApi + "]");
+                if (!shouldTriggerLastSeen(lastSeen.include, currentService, currentApi, fullPath, currentMethod)) {
+                    req.soajs.log.debug("lastSeen skipped for [" + currentService + " " + currentMethod + " " + (currentApi || fullPath) + "]");
                     return;
                 }
 

package/mw/url/index.js

@@ -8,9 +8,23 @@
  * found in the LICENSE file at the root of this repository
  */
 
-const url = require('url');
 let libParseURL = require('../../lib/parseURL');
 
+/**
+ * Parse URL using WHATWG URL API and return object compatible with legacy url.parse()
+ * @param {string} urlString - URL string to parse
+ * @returns {Object} - Object with pathname, path, and query properties
+ */
+const parseURL = (urlString) => {
+	const urlObj = new URL(urlString, 'http://localhost');
+	const search = urlObj.search || '';
+	return {
+		pathname: urlObj.pathname,
+		path: urlObj.pathname + search,
+		query: Object.fromEntries(urlObj.searchParams)
+	};
+};
+
 /**
  * Assure req param (soajs & soajs.controller)
  * Parse url and fetch service info (soajs.controller.serviceParams)
@@ -30,7 +44,7 @@ module.exports = (configuration) => {
 			req.soajs.controller = {};
 		}
 
-		let parsedUrl = url.parse(req.url, true);
+		let parsedUrl = parseURL(req.url);
 		if (!req.query && parsedUrl.query) {
 			req.query = parsedUrl.query;
 		}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "soajs.controller",
   "description": "soajs multi tenant API gateway",
-  "version": "4.3.1",
+  "version": "4.3.3",
   "author": {
     "name": "soajs team",
     "email": "team@soajs.org"

package/server/maintenance.js

@@ -14,8 +14,22 @@ const registryModule = require("./../modules/registry");
 
 const httpProxy = require('http-proxy');
 const http = require('http');
-const url = require('url');
 const soajsLib = require("soajs.core.libs");
+
+/**
+ * Parse URL using WHATWG URL API and return object compatible with legacy url.parse()
+ * @param {string} urlString - URL string to parse
+ * @returns {Object} - Object with pathname, path, and query properties
+ */
+const parseURL = (urlString) => {
+	const urlObj = new URL(urlString, 'http://localhost');
+	const search = urlObj.search || '';
+	return {
+		pathname: urlObj.pathname,
+		path: urlObj.pathname + search,
+		query: Object.fromEntries(urlObj.searchParams)
+	};
+};
 const soajsUtils = soajsLib.utils;
 
 const packageInfo = require("../package.json");
@@ -148,7 +162,7 @@ let Maintenance = (core, log, param, serviceIp, regEnvironment, awareness_mw, so
 		log.error('Internal proxy error: ' + error);
 		
 		res.writeHead(200, {'Content-Type': 'application/json'});
-		let parsedUrl = url.parse(req.url, true);
+		let parsedUrl = parseURL(req.url);
 		let response = maintenanceResponse(parsedUrl, param, '/proxySocket');
 		return res.end(JSON.stringify(response));
 	});
@@ -159,7 +173,7 @@ let Maintenance = (core, log, param, serviceIp, regEnvironment, awareness_mw, so
 			res.writeHead(200, {'Content-Type': 'image/x-icon'});
 			return res.end();
 		}
-		let parsedUrl = url.parse(req.url, true);
+		let parsedUrl = parseURL(req.url);
 		
 		if (parsedUrl.pathname === '/reloadRegistry') {
 			reloadRegistry(parsedUrl, core, log, param, serviceIp, (response) => {

package/test/unit/lib/parseURL.js

@@ -1,13 +1,27 @@
 "use strict";
 
-const url = require('url');
 const helper = require("../../helper.js");
 const lib = helper.requireModule('./lib/parseURL');
 const assert = require('assert');
 
+/**
+ * Parse URL using WHATWG URL API and return object compatible with legacy url.parse()
+ * @param {string} urlString - URL string to parse
+ * @returns {Object} - Object with pathname, path, and query properties
+ */
+const parseURL = (urlString) => {
+	const urlObj = new URL(urlString, 'http://localhost');
+	const search = urlObj.search || '';
+	return {
+		pathname: urlObj.pathname,
+		path: urlObj.pathname + search,
+		query: Object.fromEntries(urlObj.searchParams)
+	};
+};
+
 describe("Unit test for: lib - parseURL", () => {
     let uri = '/micro2/v1.1/hello';
-    let parsedURL = url.parse(uri, true);
+    let parsedURL = parseURL(uri);
     it("Vanilla test with v1.1", (done) => {
         let response = lib(uri, parsedURL);
         assert.deepStrictEqual(response.name, 'micro2', "lib.parseURL vanilla test with v1.1 failed for name");
@@ -16,10 +30,10 @@ describe("Unit test for: lib - parseURL", () => {
     });
     it("Vanilla test with :1.1", (done) => {
         uri = '/micro2:1.1/hello';
-        parsedURL = url.parse(uri, true);
+        parsedURL = parseURL(uri);
         let response = lib(uri, parsedURL);
         assert.deepStrictEqual(response.name, 'micro2', "lib.parseURL vanilla test with 1:1 failed for name");
         assert.deepStrictEqual(response.service_v, '1.1', "lib.parseURL vanilla test with 1:1 failed version");
         done();
     });
-});
+});

package/test/unit/mw/gotoService/monitorBuffer.js

@@ -0,0 +1,306 @@
+"use strict";
+
+/**
+ * @license
+ * Copyright SOAJS All Rights Reserved.
+ *
+ * Use of this source code is governed by an Apache license that can be
+ * found in the LICENSE file at the root of this repository
+ */
+
+const assert = require('assert');
+
+describe("Unit test for: mw - gotoService monitor buffer", function () {
+
+	// We need to test the buffer module functions directly
+	// Since they are module-level in redirectToService.js, we'll test the logic patterns
+
+	describe("Buffer configuration parsing", function () {
+
+		it("should recognize buffer config with time only", function (done) {
+			let monitor = {
+				"buffer": {
+					"time": 5000
+				}
+			};
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			assert.strictEqual(hasBuffer, true);
+			done();
+		});
+
+		it("should recognize buffer config with limit only", function (done) {
+			let monitor = {
+				"buffer": {
+					"limit": 100
+				}
+			};
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			assert.strictEqual(hasBuffer, true);
+			done();
+		});
+
+		it("should recognize buffer config with both time and limit", function (done) {
+			let monitor = {
+				"buffer": {
+					"time": 5000,
+					"limit": 100
+				}
+			};
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			assert.strictEqual(hasBuffer, true);
+			done();
+		});
+
+		it("should not recognize buffer config when buffer is not set", function (done) {
+			let monitor = {
+				"req_info": true
+			};
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			assert.strictEqual(!!hasBuffer, false);
+			done();
+		});
+
+		it("should not recognize buffer config when buffer is empty", function (done) {
+			let monitor = {
+				"buffer": {}
+			};
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			assert.strictEqual(!!hasBuffer, false);
+			done();
+		});
+
+		it("should not recognize buffer when monitor is null", function (done) {
+			let monitor = null;
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			assert.strictEqual(!!hasBuffer, false);
+			done();
+		});
+	});
+
+	describe("Buffer limit threshold logic", function () {
+
+		it("should trigger flush when buffer reaches limit", function (done) {
+			let monitorBuffer = [];
+			let bufferLimit = 3;
+
+			// Simulate adding items
+			for (let i = 0; i < 3; i++) {
+				monitorBuffer.push({ name: "test", api: "/test" + i });
+			}
+
+			let shouldFlush = bufferLimit && monitorBuffer.length >= bufferLimit;
+			assert.strictEqual(shouldFlush, true);
+			done();
+		});
+
+		it("should not trigger flush when buffer is below limit", function (done) {
+			let monitorBuffer = [];
+			let bufferLimit = 10;
+
+			// Simulate adding items
+			for (let i = 0; i < 5; i++) {
+				monitorBuffer.push({ name: "test", api: "/test" + i });
+			}
+
+			let shouldFlush = bufferLimit && monitorBuffer.length >= bufferLimit;
+			assert.strictEqual(shouldFlush, false);
+			done();
+		});
+
+		it("should not trigger flush when no limit is set", function (done) {
+			let monitorBuffer = [];
+			let bufferLimit = null;
+
+			// Simulate adding items
+			for (let i = 0; i < 100; i++) {
+				monitorBuffer.push({ name: "test", api: "/test" + i });
+			}
+
+			let shouldFlush = bufferLimit && monitorBuffer.length >= bufferLimit;
+			assert.strictEqual(shouldFlush, false);
+			done();
+		});
+	});
+
+	describe("Buffer time threshold logic", function () {
+
+		it("should start timer when time threshold is set and no timer exists", function (done) {
+			let monitorFlushTimer = null;
+			let bufferTime = 5000;
+
+			let shouldStartTimer = bufferTime && !monitorFlushTimer;
+			assert.strictEqual(shouldStartTimer, true);
+			done();
+		});
+
+		it("should not start timer when timer already exists", function (done) {
+			let monitorFlushTimer = setTimeout(() => {}, 5000);
+			let bufferTime = 5000;
+
+			let shouldStartTimer = bufferTime && !monitorFlushTimer;
+			assert.strictEqual(shouldStartTimer, false);
+
+			clearTimeout(monitorFlushTimer);
+			done();
+		});
+
+		it("should not start timer when no time threshold is set", function (done) {
+			let monitorFlushTimer = null;
+			let bufferTime = null;
+
+			let shouldStartTimer = bufferTime && !monitorFlushTimer;
+			assert.strictEqual(!!shouldStartTimer, false);
+			done();
+		});
+	});
+
+	describe("Buffer flush conditions", function () {
+
+		it("should not flush when buffer is empty", function (done) {
+			let monitorBuffer = [];
+			let monitorFlushInProgress = false;
+
+			let shouldFlush = !(monitorFlushInProgress || monitorBuffer.length === 0);
+			assert.strictEqual(shouldFlush, false);
+			done();
+		});
+
+		it("should not flush when flush is already in progress", function (done) {
+			let monitorBuffer = [{ name: "test" }];
+			let monitorFlushInProgress = true;
+
+			let shouldFlush = !(monitorFlushInProgress || monitorBuffer.length === 0);
+			assert.strictEqual(shouldFlush, false);
+			done();
+		});
+
+		it("should flush when buffer has items and no flush in progress", function (done) {
+			let monitorBuffer = [{ name: "test" }];
+			let monitorFlushInProgress = false;
+
+			let shouldFlush = !(monitorFlushInProgress || monitorBuffer.length === 0);
+			assert.strictEqual(shouldFlush, true);
+			done();
+		});
+	});
+
+	describe("Monitor document transformation", function () {
+
+		it("should convert body to string before sending", function (done) {
+			let doc = {
+				name: "test",
+				body: Buffer.from("test body")
+			};
+
+			if (doc.body) {
+				doc.body = doc.body.toString();
+			}
+
+			assert.strictEqual(typeof doc.body, "string");
+			assert.strictEqual(doc.body, "test body");
+			done();
+		});
+
+		it("should convert response to string before sending", function (done) {
+			let doc = {
+				name: "test",
+				response: Buffer.from('{"result": true}')
+			};
+
+			if (doc.response) {
+				doc.response = doc.response.toString();
+			}
+
+			assert.strictEqual(typeof doc.response, "string");
+			assert.strictEqual(doc.response, '{"result": true}');
+			done();
+		});
+
+		it("should handle doc without body or response", function (done) {
+			let doc = {
+				name: "test",
+				api: "/test"
+			};
+
+			if (doc.body) {
+				doc.body = doc.body.toString();
+			}
+			if (doc.response) {
+				doc.response = doc.response.toString();
+			}
+
+			assert.strictEqual(doc.body, undefined);
+			assert.strictEqual(doc.response, undefined);
+			done();
+		});
+	});
+
+	describe("Backward compatibility", function () {
+
+		it("should send immediately when no buffer config (backward compatible)", function (done) {
+			let monitor = {
+				"req_info": true,
+				"req_response": true
+			};
+
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			let shouldSendImmediately = !hasBuffer;
+
+			assert.strictEqual(shouldSendImmediately, true);
+			done();
+		});
+
+		it("should use buffer when buffer config is present", function (done) {
+			let monitor = {
+				"req_info": true,
+				"req_response": true,
+				"buffer": {
+					"time": 5000,
+					"limit": 100
+				}
+			};
+
+			let hasBuffer = monitor && monitor.buffer && (monitor.buffer.time || monitor.buffer.limit);
+			let shouldSendImmediately = !hasBuffer;
+
+			assert.strictEqual(shouldSendImmediately, false);
+			done();
+		});
+	});
+
+	describe("Buffer retry logic", function () {
+
+		it("should put items back in buffer when host not found", function (done) {
+			let monitorBuffer = [];
+			let itemsToSend = [{ name: "test1" }, { name: "test2" }];
+			let host = null;
+
+			// Simulate host not found - items should go back to buffer
+			if (!host) {
+				monitorBuffer = itemsToSend.concat(monitorBuffer);
+			}
+
+			assert.strictEqual(monitorBuffer.length, 2);
+			assert.strictEqual(monitorBuffer[0].name, "test1");
+			done();
+		});
+
+		it("should preserve order when putting items back", function (done) {
+			let monitorBuffer = [{ name: "new1" }];
+			let itemsToSend = [{ name: "old1" }, { name: "old2" }];
+			let host = null;
+
+			// Simulate host not found - items should go back to buffer
+			if (!host) {
+				monitorBuffer = itemsToSend.concat(monitorBuffer);
+			}
+
+			assert.strictEqual(monitorBuffer.length, 3);
+			assert.strictEqual(monitorBuffer[0].name, "old1");
+			assert.strictEqual(monitorBuffer[1].name, "old2");
+			assert.strictEqual(monitorBuffer[2].name, "new1");
+			done();
+		});
+	});
+
+});