soajs.controller 4.3.4 → 4.3.5

package/test/unit/mw/idempotency/index.js

@@ -0,0 +1,354 @@
+"use strict";
+
+const helper = require("../../../helper.js");
+const mw = helper.requireModule('./mw/idempotency/index');
+const assert = require('assert');
+
+describe("Unit test for: mw - idempotency", () => {
+
+	let mockLog = {
+		debug: () => {},
+		info: () => {},
+		warn: () => {},
+		error: () => {}
+	};
+
+	let mockConfig = {
+		log: mockLog,
+		gatewayDB: {}
+	};
+
+	describe("middleware initialization", () => {
+		it("should return a function", (done) => {
+			let functionMw = mw(mockConfig);
+			assert.strictEqual(typeof functionMw, 'function');
+			done();
+		});
+	});
+
+	describe("no idempotency key header", () => {
+		it("should call next() when no Idempotency-Key header", (done) => {
+			let req = {
+				headers: {},
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: { custom: {} }
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+	});
+
+	describe("invalid idempotency key format", () => {
+		it("should return 400 for invalid UUID format", (done) => {
+			let responseData = null;
+			let req = {
+				headers: { 'idempotency-key': 'not-a-valid-uuid' },
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: { custom: {} },
+					controllerResponse: (data) => {
+						responseData = data;
+					}
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, () => {
+				assert.fail('Should not call next');
+			});
+			setTimeout(() => {
+				assert.notStrictEqual(responseData, null);
+				assert.strictEqual(responseData.status, 400);
+				assert.strictEqual(responseData.code, 180);
+				done();
+			}, 10);
+		});
+
+		it("should return 400 for UUID v1 format", (done) => {
+			let responseData = null;
+			let req = {
+				headers: { 'idempotency-key': 'a1b2c3d4-e5f6-1789-abcd-ef0123456789' }, // v1 UUID
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: { custom: {} },
+					controllerResponse: (data) => {
+						responseData = data;
+					}
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, () => {
+				assert.fail('Should not call next');
+			});
+			setTimeout(() => {
+				assert.notStrictEqual(responseData, null);
+				assert.strictEqual(responseData.status, 400);
+				assert.strictEqual(responseData.code, 180);
+				done();
+			}, 10);
+		});
+	});
+
+	describe("valid idempotency key", () => {
+		it("should call next() when no configuration exists", (done) => {
+			let req = {
+				headers: { 'idempotency-key': '550e8400-e29b-41d4-a716-446655440000' },
+				method: 'POST',
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: { custom: {} }
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+
+		it("should call next() for GET requests", (done) => {
+			let req = {
+				headers: { 'idempotency-key': '550e8400-e29b-41d4-a716-446655440000' },
+				method: 'GET',
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									idempotency: {
+										services: {
+											test: { enabled: true, ttl: 60000, apis: ['POST /test'] }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+
+		it("should call next() when service not configured", (done) => {
+			let req = {
+				headers: { 'idempotency-key': '550e8400-e29b-41d4-a716-446655440000' },
+				method: 'POST',
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'unconfigured', serviceInfo: ['', 'unconfigured', 'test'] } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									idempotency: {
+										services: {
+											other: { enabled: true, ttl: 60000, apis: ['POST /test'] }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+
+		it("should call next() when service not enabled", (done) => {
+			let req = {
+				headers: { 'idempotency-key': '550e8400-e29b-41d4-a716-446655440000' },
+				method: 'POST',
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									idempotency: {
+										services: {
+											test: { enabled: false, ttl: 60000, apis: ['POST /test'] }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+
+		it("should call next() when API not in configured list", (done) => {
+			let req = {
+				headers: { 'idempotency-key': '550e8400-e29b-41d4-a716-446655440000' },
+				method: 'POST',
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'other'] } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									idempotency: {
+										services: {
+											test: { enabled: true, ttl: 60000, apis: ['POST /test'] }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+	});
+
+	describe("idempotency processing", () => {
+		it("should process new request and call next()", (done) => {
+			let req = {
+				headers: { 'idempotency-key': '550e8400-e29b-41d4-a716-446655440001' },
+				method: 'POST',
+				soajs: {
+					tenant: { id: 'tenant-new' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									idempotency: {
+										model: 'memory',
+										services: {
+											test: { enabled: true, ttl: 60000, apis: ['POST /test'] }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+			let res = {
+				writeHead: function() { return this; },
+				write: function() { return true; },
+				end: function() {},
+				on: function() {}
+			};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+
+		it("should match API with path parameters", (done) => {
+			let req = {
+				headers: { 'idempotency-key': '550e8400-e29b-41d4-a716-446655440002' },
+				method: 'PUT',
+				soajs: {
+					tenant: { id: 'tenant-param' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'users', '123', 'update'] } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									idempotency: {
+										model: 'memory',
+										services: {
+											test: { enabled: true, ttl: 60000, apis: ['PUT /users/:id/update'] }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+			let res = {
+				writeHead: function() { return this; },
+				write: function() { return true; },
+				end: function() {},
+				on: function() {}
+			};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+	});
+
+	describe("UUID validation", () => {
+		it("should accept valid UUID v4", (done) => {
+			let req = {
+				headers: { 'idempotency-key': 'f47ac10b-58cc-4372-a567-0e02b2c3d479' },
+				method: 'POST',
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: { custom: {} }
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+
+		it("should accept UUID v4 with uppercase", (done) => {
+			let req = {
+				headers: { 'idempotency-key': 'F47AC10B-58CC-4372-A567-0E02B2C3D479' },
+				method: 'POST',
+				soajs: {
+					tenant: { id: '123' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: { custom: {} }
+				}
+			};
+			let res = {};
+			let functionMw = mw(mockConfig);
+			functionMw(req, res, (error) => {
+				assert.ifError(error);
+				done();
+			});
+		});
+	});
+
+});

package/test/unit/mw/idempotency/memory.js

@@ -0,0 +1,151 @@
+"use strict";
+
+const helper = require("../../../helper.js");
+const model = helper.requireModule('./mw/idempotency/model/memory');
+const assert = require('assert');
+
+describe("Unit test for: mw - idempotency/model/memory", () => {
+
+	before((done) => {
+		model.init({
+			debug: () => {},
+			info: () => {},
+			error: () => {}
+		});
+		done();
+	});
+
+	afterEach((done) => {
+		// Clean up between tests
+		model.unlock({ l1: 'tenant1', l2: 'key1' });
+		model.unlock({ l1: 'tenant1', l2: 'key2' });
+		model.unlock({ l1: 'tenant2', l2: 'key1' });
+		done();
+	});
+
+	describe("get", () => {
+		it("should return null for non-existent key", (done) => {
+			let result = model.get({ l1: 'tenant1', l2: 'nonexistent' });
+			assert.strictEqual(result, null);
+			done();
+		});
+
+		it("should return entry after lock", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 60000);
+			let result = model.get(key);
+			assert.notStrictEqual(result, null);
+			assert.strictEqual(result.status, 'in_flight');
+			done();
+		});
+
+		it("should return null for expired entry", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 1); // 1ms TTL
+			setTimeout(() => {
+				let result = model.get(key);
+				assert.strictEqual(result, null);
+				done();
+			}, 10);
+		});
+	});
+
+	describe("lock", () => {
+		it("should successfully lock a new key", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			let result = model.lock(key, 60000);
+			assert.strictEqual(result, true);
+			done();
+		});
+
+		it("should fail to lock an already locked key", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 60000);
+			let result = model.lock(key, 60000);
+			assert.strictEqual(result, false);
+			done();
+		});
+
+		it("should allow locking after key expires", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 1); // 1ms TTL
+			setTimeout(() => {
+				let result = model.lock(key, 60000);
+				assert.strictEqual(result, true);
+				done();
+			}, 10);
+		});
+
+		it("should isolate keys by tenant", (done) => {
+			let key1 = { l1: 'tenant1', l2: 'key1' };
+			let key2 = { l1: 'tenant2', l2: 'key1' };
+			let result1 = model.lock(key1, 60000);
+			let result2 = model.lock(key2, 60000);
+			assert.strictEqual(result1, true);
+			assert.strictEqual(result2, true);
+			done();
+		});
+	});
+
+	describe("complete", () => {
+		it("should store response data", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			let response = {
+				statusCode: 200,
+				headers: { 'Content-Type': 'application/json' },
+				body: '{"result": true}'
+			};
+			model.lock(key, 60000);
+			model.complete(key, response, 60000);
+			let result = model.get(key);
+			assert.notStrictEqual(result, null);
+			assert.strictEqual(result.status, 'completed');
+			assert.deepStrictEqual(result.response, response);
+			done();
+		});
+
+		it("should update expiresAt on complete", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 100);
+			let afterLock = model.get(key);
+			model.complete(key, { statusCode: 200 }, 60000);
+			let afterComplete = model.get(key);
+			assert.ok(afterComplete.expiresAt > afterLock.expiresAt);
+			done();
+		});
+	});
+
+	describe("unlock", () => {
+		it("should remove locked key", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 60000);
+			model.unlock(key);
+			let result = model.get(key);
+			assert.strictEqual(result, null);
+			done();
+		});
+
+		it("should handle unlock of non-existent key", (done) => {
+			let key = { l1: 'tenant1', l2: 'nonexistent' };
+			// Should not throw
+			model.unlock(key);
+			done();
+		});
+	});
+
+	describe("cleanupExpiredEntries", () => {
+		it("should remove expired entries", (done) => {
+			let key1 = { l1: 'tenant1', l2: 'key1' };
+			let key2 = { l1: 'tenant1', l2: 'key2' };
+			model.lock(key1, 1); // expires immediately
+			model.lock(key2, 60000); // long TTL
+			setTimeout(() => {
+				model.cleanupExpiredEntries();
+				assert.strictEqual(model.get(key1), null);
+				assert.notStrictEqual(model.get(key2), null);
+				done();
+			}, 10);
+		});
+	});
+
+});