soajs.controller 4.3.17 → 4.3.19

package/test/integration/UC5-tenant-access/index.js

@@ -0,0 +1,153 @@
+"use strict";
+
+const assert = require('assert');
+const express = require('express');
+const helper = require("../../helper.js");
+const requester = require('../requester');
+let Controller = helper.requireModule('./server/controller');
+let localConfig = helper.requireModule('./config.js');
+
+let mock = require('../UC2-http-methods/service-mock/index.js');
+
+//NOTE: the users of these tokens live in tenant HOME, the key belongs to tenant DBTN which names
+//		the department resolver in its profile
+const memberToken = "d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d901";
+const outsiderToken = "d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d902";
+const ownerToken = "cfb209a91b23896820f510aadbf1f4284b512123";
+
+function startResolver(calls, callback) {
+	const sApp = express();
+	const mApp = express();
+	sApp.use(express.json());
+	sApp.post('/tenant/access', (req, res) => {
+		calls.push({ "body": req.body, "injectObj": JSON.parse(req.headers.soajsinjectobj) });
+		if (req.body.user.username === "dept_member" && req.body.subject === "dept_1") {
+			return res.json({
+				"result": true,
+				"data": {
+					"access": true,
+					"groups": ["member"],
+					"groupsConfig": { "allowedPackages": { "DSBRD": ["DSBRD_OWNER"] } }
+				}
+			});
+		}
+		return res.json({ "result": true, "data": { "access": false } });
+	});
+	mApp.get('/heartbeat', (req, res) => {
+		res.json({ "result": true, "ts": Date.now(), "service": { "service": "departments", "type": "rest", "route": "/heartbeat" } });
+	});
+	let sAppServer = sApp.listen(4013, () => {
+		let mAppServer = mApp.listen(5014, () => {
+			return callback({ "sAppServer": sAppServer, "mAppServer": mAppServer, "name": "departments" });
+		});
+	});
+}
+
+describe("Integration for Usecase 5 - tenant access resolver", function () {
+	let extKey = "3d90163cf9d6b3076ad26aa5ed58556348069258e5c6c941ee0f18448b570ad1c5c790e2d2a1989680c55f4904e2005ff5f8e71606e4aa641e67882f4210ebbc5460ff305dcb36e6ec2a2299cf0448ef60b9e38f41950ec251c1cf41f05f3ce9";
+
+	let c = new Controller({
+		"serviceName": localConfig.serviceName,
+		"serviceVersion": localConfig.serviceVersion,
+		"serviceGroup": localConfig.serviceGroup,
+		"servicePort": localConfig.servicePort,
+		"maintenance": localConfig.maintenance
+	});
+	let registry = null;
+	let log = null;
+	let service = null;
+	let server = null;
+	let serverMaintenance = null;
+	let httpmethods = null;
+	let resolver = null;
+	let calls = [];
+
+	function call(token, cb) {
+		let options = {
+			uri: 'http://127.0.0.1:' + localConfig.servicePort + '/httpmethods/myroute',
+			headers: {
+				'Content-Type': 'application/json',
+				key: extKey
+			},
+			"qs": {
+				access_token: token
+			}
+		};
+		requester('get', options, cb);
+	}
+
+	before((done) => {
+		startResolver(calls, (servers) => {
+			resolver = servers;
+			mock.startServer(null, function (servers) {
+				httpmethods = servers;
+			});
+			c.init((_registry, _log, _service, _server, _serverMaintenance) => {
+				registry = _registry;
+				log = _log;
+				service = _service;
+				server = _server;
+				serverMaintenance = _serverMaintenance;
+				c.start(registry, log, service, server, serverMaintenance, () => {
+					setTimeout(function () {
+						done();
+					}, 5000);
+				});
+			});
+		});
+	});
+	beforeEach(() => {
+		calls.length = 0;
+	});
+
+	it("department member switching to the tenant gets the resolver ACL", function (done) {
+		call(memberToken, (error, body) => {
+			assert.ifError(error);
+			assert.ok(body);
+			assert.strictEqual(body.result, true, JSON.stringify(body.errors));
+			assert.deepStrictEqual(body.data.method, 'GET');
+			assert.strictEqual(calls.length, 1);
+			assert.deepStrictEqual(calls[0].body, {
+				"user": {
+					"id": "5c8d0c505653de3985aa1001",
+					"username": "dept_member",
+					"tenant": { "id": "5c0e74ba9acc3c5a84a51260", "code": "HOME" }
+				},
+				"tenant": { "id": "5c0e74ba9acc3c5a84a51259", "code": "DBTN" },
+				"subject": "dept_1"
+			});
+			assert.strictEqual(calls[0].injectObj.tenant.id, "5c0e74ba9acc3c5a84a51259");
+			assert.strictEqual(calls[0].injectObj.application.product, "DSBRD");
+			done();
+		});
+	});
+
+	it("user outside the department is refused after the urac fallback", function (done) {
+		call(outsiderToken, (error, body) => {
+			assert.ok(body);
+			assert.strictEqual(body.result, false);
+			assert.deepStrictEqual(body.errors.codes, [146]);
+			assert.strictEqual(calls.length, 1);
+			done();
+		});
+	});
+
+	it("user of the tenant itself does not call the resolver", function (done) {
+		call(ownerToken, (error, body) => {
+			assert.ifError(error);
+			assert.ok(body);
+			assert.strictEqual(body.result, true, JSON.stringify(body.errors));
+			assert.strictEqual(calls.length, 0);
+			done();
+		});
+	});
+
+	after((done) => {
+		mock.killServer(httpmethods);
+		resolver.sAppServer.close();
+		resolver.mAppServer.close();
+		c.stop(registry, log, service, server, serverMaintenance, () => {
+			done();
+		});
+	});
+});

package/test/integration/UC6-idempotency/index.js

@@ -0,0 +1,197 @@
+"use strict";
+
+const assert = require('assert');
+const crypto = require('crypto');
+const express = require('express');
+const request = require('request');
+const helper = require("../../helper.js");
+let Controller = helper.requireModule('./server/controller');
+let localConfig = helper.requireModule('./config.js');
+
+//NOTE: the gateway custom registry turns idempotency on with the mongo model for every route of the
+//		idempotent service, and throttles /throttled to one call per minute
+const ownerToken = "cfb209a91b23896820f510aadbf1f4284b512123";
+
+function startService(calls, callback) {
+	const sApp = express();
+	const mApp = express();
+	let failed = false;
+	let count = (route) => {
+		calls[route] = (calls[route] || 0) + 1;
+	};
+	sApp.post('/ok', (req, res) => {
+		count("ok");
+		res.json({ "result": true, "data": { "call": calls.ok } });
+	});
+	sApp.post('/fail', (req, res) => {
+		count("fail");
+		if (!failed) {
+			failed = true;
+			return res.status(503).json({ "result": false, "errors": { "codes": [503], "details": [{ "code": 503, "message": "unavailable" }] } });
+		}
+		res.json({ "result": true, "data": { "call": calls.fail } });
+	});
+	sApp.post('/bad', (req, res) => {
+		count("bad");
+		res.status(400).json({ "result": false, "errors": { "codes": [400], "details": [{ "code": 400, "message": "bad input" }] } });
+	});
+	sApp.post('/slow', (req, res) => {
+		count("slow");
+		setTimeout(() => {
+			res.json({ "result": true, "data": { "call": calls.slow } });
+		}, 1500);
+	});
+	sApp.post('/throttled', (req, res) => {
+		count("throttled");
+		res.json({ "result": true, "data": { "call": calls.throttled } });
+	});
+	mApp.get('/heartbeat', (req, res) => {
+		res.json({ "result": true, "ts": Date.now(), "service": { "service": "idempotent", "type": "rest", "route": "/heartbeat" } });
+	});
+	let sAppServer = sApp.listen(4014, () => {
+		let mAppServer = mApp.listen(5015, () => {
+			return callback({ "sAppServer": sAppServer, "mAppServer": mAppServer });
+		});
+	});
+}
+
+describe("Integration for Usecase 6 - idempotency", function () {
+	let extKey = "3d90163cf9d6b3076ad26aa5ed58556348069258e5c6c941ee0f18448b570ad1c5c790e2d2a1989680c55f4904e2005ff5f8e71606e4aa641e67882f4210ebbc5460ff305dcb36e6ec2a2299cf0448ef60b9e38f41950ec251c1cf41f05f3ce9";
+
+	let c = new Controller({
+		"serviceName": localConfig.serviceName,
+		"serviceVersion": localConfig.serviceVersion,
+		"serviceGroup": localConfig.serviceGroup,
+		"servicePort": localConfig.servicePort,
+		"maintenance": localConfig.maintenance
+	});
+	let registry = null;
+	let log = null;
+	let service = null;
+	let server = null;
+	let serverMaintenance = null;
+	let mockServers = null;
+	let calls = {};
+
+	function call(route, key, cb) {
+		request.post({
+			"uri": 'http://127.0.0.1:' + localConfig.servicePort + '/idempotent' + route,
+			"json": true,
+			"headers": {
+				"key": extKey,
+				"idempotency-key": key,
+				"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36"
+			},
+			"qs": { "access_token": ownerToken }
+		}, (error, response, body) => {
+			assert.ifError(error);
+			return cb(response.statusCode, body);
+		});
+	}
+
+	before((done) => {
+		//NOTE: the unit tests run in the same process and connect the idempotency mongo model to a dummy
+		//		database, the model connects only once, drop it so the gateway connects it to the real one
+		helper.requireModule('./mw/idempotency/model/mongo').mongo = null;
+		startService(calls, (servers) => {
+			mockServers = servers;
+			c.init((_registry, _log, _service, _server, _serverMaintenance) => {
+				registry = _registry;
+				log = _log;
+				service = _service;
+				server = _server;
+				serverMaintenance = _serverMaintenance;
+				c.start(registry, log, service, server, serverMaintenance, () => {
+					setTimeout(function () {
+						done();
+					}, 5000);
+				});
+			});
+		});
+	});
+
+	it("a service answer is completed and replayed", function (done) {
+		let key = crypto.randomUUID();
+		call("/ok", key, (status, body) => {
+			assert.strictEqual(status, 200, JSON.stringify(body));
+			assert.strictEqual(calls.ok, 1);
+			call("/ok", key, (status, body) => {
+				assert.strictEqual(status, 200);
+				assert.strictEqual(body.data.call, 1);
+				assert.strictEqual(calls.ok, 1);
+				done();
+			});
+		});
+	});
+
+	it("a 4xx of the service is completed and replayed", function (done) {
+		let key = crypto.randomUUID();
+		call("/bad", key, (status) => {
+			assert.strictEqual(status, 400);
+			call("/bad", key, (status) => {
+				assert.strictEqual(status, 400);
+				assert.strictEqual(calls.bad, 1);
+				done();
+			});
+		});
+	});
+
+	it("a 5xx of the service releases the key, the retry reaches the service", function (done) {
+		let key = crypto.randomUUID();
+		call("/fail", key, (status) => {
+			assert.strictEqual(status, 503);
+			call("/fail", key, (status, body) => {
+				assert.strictEqual(status, 200, JSON.stringify(body));
+				assert.strictEqual(calls.fail, 2);
+				call("/fail", key, (status, body) => {
+					assert.strictEqual(status, 200);
+					assert.strictEqual(body.data.call, 2);
+					assert.strictEqual(calls.fail, 2);
+					done();
+				});
+			});
+		});
+	});
+
+	it("a duplicate while the first is running gets 409/181", function (done) {
+		let key = crypto.randomUUID();
+		let first = null;
+		call("/slow", key, (status) => {
+			first = status;
+		});
+		setTimeout(() => {
+			call("/slow", key, (status, body) => {
+				assert.strictEqual(status, 409);
+				assert.deepStrictEqual(body.errors.codes, [181]);
+				setTimeout(() => {
+					assert.strictEqual(first, 200);
+					assert.strictEqual(calls.slow, 1);
+					done();
+				}, 2000);
+			});
+		}, 300);
+	});
+
+	it("a throttled request releases the key, the retry is not refused with 409", function (done) {
+		call("/throttled", crypto.randomUUID(), (status, body) => {
+			assert.strictEqual(status, 200, JSON.stringify(body));
+			let key = crypto.randomUUID();
+			call("/throttled", key, (status) => {
+				assert.strictEqual(status, 429);
+				call("/throttled", key, (status, body) => {
+					assert.strictEqual(status, 429, JSON.stringify(body));
+					assert.strictEqual(calls.throttled, 1);
+					done();
+				});
+			});
+		});
+	});
+
+	after((done) => {
+		mockServers.sAppServer.close();
+		mockServers.mAppServer.close();
+		c.stop(registry, log, service, server, serverMaintenance, () => {
+			done();
+		});
+	});
+});

package/test/integration/index.js

@@ -36,6 +36,14 @@ describe("starting integration tests", () => {
 		// to test roaming
 		require("./UC3-roaming/index.js");
 		
+		
+		// to test the tenant access resolver
+		require("./UC5-tenant-access/index.js");
+		
+		
+		// to test idempotency with the mongo model
+		require("./UC6-idempotency/index.js");
+		
 		done();
 	});
 });

package/test/unit/index.js

@@ -29,6 +29,7 @@ describe("Starting Gateway Unit test", () => {
 
         require("./mw/mt/index.js");
         require("./mw/mt/urac.js");
+        require("./mw/mt/tenantAccess.js");
         require("./mw/mt/utils.js");
         require("./mw/mt/lib.js");
 
@@ -38,6 +39,7 @@ describe("Starting Gateway Unit test", () => {
         require("./mw/traffic/index.js");
         require("./mw/idempotency/index.js");
         require("./mw/idempotency/memory.js");
+        require("./mw/idempotency/mongo.js");
         require("./mw/cache/index.js");
         require("./mw/cache/memory.js");
         require("./mw/lastSeen/index.js");

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' }
+		}]);
+	});
+});