soajs.controller 4.3.18 → 4.3.20

package/test/unit/mw/cache/mongo.js

@@ -0,0 +1,104 @@
+"use strict";
+
+const helper = require("../../../helper.js");
+const model = helper.requireModule('./mw/cache/model/mongo');
+const assert = require('assert');
+
+describe("Unit test for: mw - cache/model/mongo invalidation", () => {
+
+	let calls = null;
+	let invalidation = null;
+	let deleted = 0;
+	let originalMongo = null;
+	let originalLog = null;
+
+	before(() => {
+		originalMongo = model.mongo;
+		originalLog = model.log;
+		model.log = {
+			debug: () => {},
+			info: () => {},
+			error: () => {}
+		};
+		model.mongo = {
+			findOne: async (col, condition) => {
+				calls.push({ "op": "findOne", col, condition });
+				return invalidation;
+			},
+			updateOne: async (col, condition, s, options) => {
+				calls.push({ "op": "updateOne", col, condition, s, options });
+			},
+			deleteMany: async (col, condition) => {
+				calls.push({ "op": "deleteMany", col, condition });
+				return { deletedCount: deleted };
+			}
+		};
+	});
+	after(() => {
+		model.mongo = originalMongo;
+		model.log = originalLog;
+	});
+	beforeEach(() => {
+		calls = [];
+		invalidation = null;
+		deleted = 0;
+	});
+
+	let key = { l1: 'tenant1', l2: 'spaces:GET:/spaces::u:user-1' };
+	let response = { statusCode: 200, headers: {}, body: '[]' };
+
+	it("set stores the fields an invalidation matches on", async () => {
+		let stored = await model.set(key, response, 60000, { service: 'spaces', api: 'GET /spaces', user: 'user-1', startedAt: Date.now() });
+		assert.strictEqual(stored, true);
+		let update = calls.find((c) => c.op === "updateOne");
+		assert.strictEqual(update.col, 'cache_store');
+		assert.strictEqual(update.s.$set.service, 'spaces');
+		assert.strictEqual(update.s.$set.api, 'GET /spaces');
+		assert.strictEqual(update.s.$set.user, 'user-1');
+	});
+
+	it("set looks for an invalidation after the request started, for that api or all, that user or all", async () => {
+		let startedAt = Date.now();
+		await model.set(key, response, 60000, { service: 'spaces', api: 'GET /spaces', user: 'user-1', startedAt: startedAt });
+		let lookup = calls.find((c) => c.op === "findOne");
+		assert.strictEqual(lookup.col, 'cache_invalidation');
+		assert.deepStrictEqual(lookup.condition, {
+			l1: 'tenant1',
+			service: 'spaces',
+			api: { $in: ['GET /spaces', null] },
+			user: { $in: ['user-1', null] },
+			clearedAt: { $gt: new Date(startedAt) }
+		});
+	});
+
+	it("set does not store a response read before an invalidation", async () => {
+		invalidation = { clearedAt: new Date() };
+		let stored = await model.set(key, response, 60000, { service: 'spaces', api: 'GET /spaces', user: 'user-1', startedAt: Date.now() - 1000 });
+		assert.strictEqual(stored, false);
+		assert.strictEqual(calls.filter((c) => c.op === "updateOne").length, 0);
+	});
+
+	it("set without meta stores as before", async () => {
+		let stored = await model.set(key, response, 60000);
+		assert.strictEqual(stored, true);
+		assert.strictEqual(calls.filter((c) => c.op === "findOne").length, 0);
+	});
+
+	it("invalidateMatching records the invalidation before removing", async () => {
+		deleted = 3;
+		let removed = await model.invalidateMatching({ tenant: 'tenant1', service: 'spaces', api: 'GET /spaces', user: 'user-1' });
+		assert.strictEqual(removed, 3);
+		assert.deepStrictEqual(calls.map((c) => c.op), ['updateOne', 'deleteMany']);
+		assert.strictEqual(calls[0].col, 'cache_invalidation');
+		assert.deepStrictEqual(calls[0].condition, { l1: 'tenant1', service: 'spaces', api: 'GET /spaces', user: 'user-1' });
+		assert.ok(calls[0].s.$set.clearedAt instanceof Date);
+		assert.ok(calls[0].s.$set.expiresAt > calls[0].s.$set.clearedAt);
+		assert.deepStrictEqual(calls[1].condition, { l1: 'tenant1', service: 'spaces', api: 'GET /spaces', user: 'user-1' });
+	});
+
+	it("invalidateMatching without api and user covers the whole service", async () => {
+		await model.invalidateMatching({ tenant: 'tenant1', service: 'spaces' });
+		assert.deepStrictEqual(calls[0].condition, { l1: 'tenant1', service: 'spaces', api: null, user: null });
+		assert.deepStrictEqual(calls[1].condition, { l1: 'tenant1', service: 'spaces' });
+	});
+});

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

@@ -590,4 +590,126 @@ describe("Unit test for: mw - idempotency", () => {
 		});
 	});
 
+	describe("release of the key when the request ends before the service", () => {
+		const EventEmitter = require('events');
+
+		function buildReq(idempotencyKey, answers) {
+			return {
+				headers: { 'idempotency-key': idempotencyKey },
+				method: 'POST',
+				soajs: {
+					tenant: { id: 'tenant-release' },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'test'] } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									idempotency: {
+										model: 'memory',
+										services: {
+											test: { enabled: true, ttl: 60000, apis: ['POST /test'] }
+										}
+									}
+								}
+							}
+						}
+					},
+					controllerResponse: (data) => {
+						answers.push(data);
+					}
+				}
+			};
+		}
+
+		function buildRes() {
+			let res = new EventEmitter();
+			res.replayed = null;
+			res.writeHead = (statusCode) => {
+				res.replayed = statusCode;
+				return res;
+			};
+			res.end = () => {
+			};
+			return res;
+		}
+
+		// Runs the middleware and resolves with "next" or the answer it gave
+		function run(functionMw, idempotencyKey) {
+			return new Promise((resolve) => {
+				let answers = [];
+				let req = buildReq(idempotencyKey, answers);
+				let res = buildRes();
+				functionMw(req, res, () => {
+					resolve({ "next": true, req, res, answers });
+				});
+				setTimeout(() => {
+					resolve({ "next": false, req, res, answers });
+				}, 20);
+			});
+		}
+
+		let functionMw = null;
+		before(() => {
+			functionMw = mw(mockConfig);
+		});
+
+		it("an answer before the service, a 429 for example, releases the key", async () => {
+			let key = '550e8400-e29b-41d4-a716-446655440101';
+			let first = await run(functionMw, key);
+			assert.strictEqual(first.next, true);
+			first.res.emit('finish');
+			await new Promise((r) => setTimeout(r, 5));
+			let retry = await run(functionMw, key);
+			assert.strictEqual(retry.next, true, JSON.stringify(retry.answers));
+		});
+
+		it("a client disconnect before the service releases the key", async () => {
+			let key = '550e8400-e29b-41d4-a716-446655440102';
+			let first = await run(functionMw, key);
+			assert.strictEqual(first.next, true);
+			first.res.emit('close');
+			await new Promise((r) => setTimeout(r, 5));
+			let retry = await run(functionMw, key);
+			assert.strictEqual(retry.next, true, JSON.stringify(retry.answers));
+		});
+
+		it("a proxied request is left to gotoService, a duplicate still gets 409/181", async () => {
+			let key = '550e8400-e29b-41d4-a716-446655440103';
+			let first = await run(functionMw, key);
+			assert.strictEqual(first.next, true);
+			first.req.soajs.idempotencyContext.proxied = true;
+			first.res.emit('finish');
+			await new Promise((r) => setTimeout(r, 5));
+			let duplicate = await run(functionMw, key);
+			assert.strictEqual(duplicate.next, false);
+			assert.strictEqual(duplicate.answers[0].status, 409);
+			assert.strictEqual(duplicate.answers[0].code, 181);
+		});
+
+		it("a completed request is replayed, finish does not remove it", async () => {
+			let key = '550e8400-e29b-41d4-a716-446655440104';
+			let first = await run(functionMw, key);
+			let context = first.req.soajs.idempotencyContext;
+			context.proxied = true;
+			context.model.complete(context.key, { statusCode: 201, headers: {}, body: '{}' }, context.ttl);
+			first.res.emit('finish');
+			first.res.emit('close');
+			await new Promise((r) => setTimeout(r, 5));
+			let retry = await run(functionMw, key);
+			assert.strictEqual(retry.next, false);
+			assert.strictEqual(retry.res.replayed, 201);
+		});
+
+		it("the release of an expired lock does not remove the lock of a later retry", async () => {
+			let key = '550e8400-e29b-41d4-a716-446655440105';
+			let first = await run(functionMw, key);
+			let context = first.req.soajs.idempotencyContext;
+			// the ttl of the first lock ran out and a retry locked the key again
+			context.model.get(context.key).expiresAt = Date.now() - 1;
+			assert.strictEqual(context.model.lock(context.key, 60000, 'lock-of-the-retry'), true);
+			first.res.emit('finish');
+			await new Promise((r) => setTimeout(r, 5));
+			assert.strictEqual(context.model.get(context.key).lockId, 'lock-of-the-retry');
+		});
+	});
 });

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

@@ -16,10 +16,12 @@ describe("Unit test for: mw - idempotency/model/memory", () => {
 	});
 
 	afterEach((done) => {
-		// Clean up between tests
-		model.unlock({ l1: 'tenant1', l2: 'key1' });
-		model.unlock({ l1: 'tenant1', l2: 'key2' });
-		model.unlock({ l1: 'tenant2', l2: 'key1' });
+		// Clean up between tests, unlock leaves completed entries in place so reset the store
+		model.init({
+			debug: () => {},
+			info: () => {},
+			error: () => {}
+		});
 		done();
 	});
 
@@ -133,6 +135,36 @@ describe("Unit test for: mw - idempotency/model/memory", () => {
 		});
 	});
 
+	describe("unlock only an own lock in flight", () => {
+		it("should keep a completed entry", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 60000, 'lock-a');
+			model.complete(key, { statusCode: 200 }, 60000);
+			model.unlock(key, 'lock-a');
+			let result = model.get(key);
+			assert.strictEqual(result.status, 'completed');
+			done();
+		});
+
+		it("should keep the lock of another request", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 60000, 'lock-b');
+			model.unlock(key, 'lock-a');
+			let result = model.get(key);
+			assert.strictEqual(result.status, 'in_flight');
+			assert.strictEqual(result.lockId, 'lock-b');
+			done();
+		});
+
+		it("should remove its own lock", (done) => {
+			let key = { l1: 'tenant1', l2: 'key1' };
+			model.lock(key, 60000, 'lock-a');
+			model.unlock(key, 'lock-a');
+			assert.strictEqual(model.get(key), null);
+			done();
+		});
+	});
+
 	describe("cleanupExpiredEntries", () => {
 		it("should remove expired entries", (done) => {
 			let key1 = { l1: 'tenant1', l2: 'key1' };

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

@@ -0,0 +1,62 @@
+"use strict";
+
+const helper = require("../../../helper.js");
+const model = helper.requireModule('./mw/idempotency/model/mongo');
+const assert = require('assert');
+
+describe("Unit test for: mw - idempotency/model/mongo", () => {
+
+	let calls = null;
+	let originalMongo = null;
+
+	before(() => {
+		originalMongo = model.mongo;
+		model.log = {
+			debug: () => {},
+			info: () => {},
+			error: () => {}
+		};
+		model.mongo = {
+			findOne: async (col, condition) => {
+				calls.push({ "op": "findOne", "condition": condition });
+				return null;
+			},
+			updateOne: async (col, condition, s, options) => {
+				calls.push({ "op": "updateOne", "condition": condition, "s": s, "options": options });
+			},
+			deleteOne: async (col, condition) => {
+				calls.push({ "op": "deleteOne", "condition": condition });
+			}
+		};
+	});
+	after(() => {
+		model.mongo = originalMongo;
+	});
+	beforeEach(() => {
+		calls = [];
+	});
+
+	it("lock stores the lockId", async () => {
+		let locked = await model.lock({ l1: 'tenant1', l2: 'key1' }, 60000, 'lock-a');
+		assert.strictEqual(locked, true);
+		let update = calls.find((c) => c.op === "updateOne");
+		assert.strictEqual(update.s.$set.status, 'in_flight');
+		assert.strictEqual(update.s.$set.lockId, 'lock-a');
+	});
+
+	it("unlock removes only an own record in flight", async () => {
+		await model.unlock({ l1: 'tenant1', l2: 'key1' }, 'lock-a');
+		assert.deepStrictEqual(calls, [{
+			"op": "deleteOne",
+			"condition": { l1: 'tenant1', l2: 'key1', status: 'in_flight', lockId: 'lock-a' }
+		}]);
+	});
+
+	it("unlock without a lockId still never removes a completed record", async () => {
+		await model.unlock({ l1: 'tenant1', l2: 'key1' });
+		assert.deepStrictEqual(calls, [{
+			"op": "deleteOne",
+			"condition": { l1: 'tenant1', l2: 'key1', status: 'in_flight' }
+		}]);
+	});
+});