soajs.controller 4.3.18 → 4.3.20

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/UC7-cache-invalidate/index.js

@@ -0,0 +1,209 @@
+"use strict";
+
+const assert = require('assert');
+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 caches the spaces service with the mongo model, per user except
+//		/catalog which is per tenant. Both tokens are users of the console tenant.
+const tenantId = "5c0e74ba9acc3c5a84a51259";
+const ownerToken = "cfb209a91b23896820f510aadbf1f4284b512123";
+const ownerId = "5c8d0c505653de3985aa0ffd";
+const secondToken = "c4c4e5e5f6f6a7a7b8b8c9c9d0d0e1e1f2f2a301";
+const secondId = "5c8d0c505653de3985aa2001";
+const maintenanceUri = 'http://127.0.0.1:5001/cache/invalidate';
+
+function startService(calls, callback) {
+	const sApp = express();
+	const mApp = express();
+	let answer = (name) => (req, res) => {
+		calls[name] = (calls[name] || 0) + 1;
+		res.json({ "result": true, "data": { "call": calls[name], "url": req.url } });
+	};
+	sApp.get('/spaces', answer("spaces"));
+	sApp.get('/space/:id', answer("space"));
+	sApp.get('/catalog', answer("catalog"));
+	sApp.get('/slow', (req, res) => {
+		calls.slow = (calls.slow || 0) + 1;
+		let call = calls.slow;
+		setTimeout(() => {
+			res.json({ "result": true, "data": { "call": call } });
+		}, 1000);
+	});
+	mApp.get('/heartbeat', (req, res) => {
+		res.json({ "result": true, "ts": Date.now(), "service": { "service": "spaces", "type": "rest", "route": "/heartbeat" } });
+	});
+	let sAppServer = sApp.listen(4015, () => {
+		let mAppServer = mApp.listen(5016, () => {
+			return callback({ "sAppServer": sAppServer, "mAppServer": mAppServer });
+		});
+	});
+}
+
+describe("Integration for Usecase 7 - cache invalidation", 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 = {};
+
+	// GET through the gateway, resolves with the X-Cache header and the body
+	function get(path, token) {
+		return new Promise((resolve) => {
+			request.get({
+				"uri": 'http://127.0.0.1:' + localConfig.servicePort + '/spaces' + path,
+				"json": true,
+				"headers": {
+					"key": extKey,
+					"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": token }
+			}, (error, response, body) => {
+				assert.ifError(error);
+				resolve({ "cache": response.headers['x-cache'], "status": response.statusCode, body });
+			});
+		});
+	}
+
+	function invalidate(body, method) {
+		return new Promise((resolve) => {
+			request({
+				"method": method || 'POST',
+				"uri": maintenanceUri,
+				"json": body === undefined ? true : body
+			}, (error, response, responseBody) => {
+				assert.ifError(error);
+				resolve({ "status": response.statusCode, "body": responseBody });
+			});
+		});
+	}
+
+	// the response is stored once the proxy finishes, after the client got it
+	const settle = () => new Promise((r) => setTimeout(r, 150));
+
+	before((done) => {
+		//NOTE: the unit tests run in the same process and connect the cache 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/cache/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 cached response is served from the cache", async () => {
+		let first = await get('/spaces', ownerToken);
+		assert.strictEqual(first.status, 200, JSON.stringify(first.body));
+		assert.strictEqual(first.cache, 'MISS');
+		await settle();
+		let second = await get('/spaces', ownerToken);
+		assert.strictEqual(second.cache, 'HIT');
+		assert.strictEqual(second.body.data.call, first.body.data.call);
+	});
+
+	it("one user: every query variant of the api is removed, the other user keeps theirs", async () => {
+		await get('/spaces?page=1', ownerToken);
+		await get('/spaces?page=2', ownerToken);
+		await get('/spaces', secondToken);
+		await settle();
+		assert.strictEqual((await get('/spaces?page=1', ownerToken)).cache, 'HIT');
+		assert.strictEqual((await get('/spaces', secondToken)).cache, 'HIT');
+
+		let outcome = await invalidate({ "tenant": tenantId, "service": "spaces", "api": "GET /spaces", "user": ownerId });
+		assert.strictEqual(outcome.status, 200, JSON.stringify(outcome.body));
+		assert.strictEqual(outcome.body.result, true);
+		assert.strictEqual(outcome.body.data.removed, 3);
+
+		assert.strictEqual((await get('/spaces', ownerToken)).cache, 'MISS');
+		assert.strictEqual((await get('/spaces?page=1', ownerToken)).cache, 'MISS');
+		assert.strictEqual((await get('/spaces?page=2', ownerToken)).cache, 'MISS');
+		assert.strictEqual((await get('/spaces', secondToken)).cache, 'HIT');
+	});
+
+	it("without a user every user's entries are removed", async () => {
+		await settle();
+		assert.strictEqual((await get('/spaces', ownerToken)).cache, 'HIT');
+		assert.strictEqual((await get('/spaces', secondToken)).cache, 'HIT');
+		let outcome = await invalidate({ "tenant": tenantId, "service": "spaces", "api": "GET /spaces" });
+		assert.strictEqual(outcome.status, 200);
+		assert.ok(outcome.body.data.removed >= 2);
+		assert.strictEqual((await get('/spaces', ownerToken)).cache, 'MISS');
+		assert.strictEqual((await get('/spaces', secondToken)).cache, 'MISS');
+	});
+
+	it("an api with a path param is removed for every value", async () => {
+		await get('/space/1', ownerToken);
+		await get('/space/2', ownerToken);
+		await settle();
+		assert.strictEqual((await get('/space/1', ownerToken)).cache, 'HIT');
+		let outcome = await invalidate({ "tenant": tenantId, "service": "spaces", "api": "GET /space/:id", "user": ownerId });
+		assert.strictEqual(outcome.body.data.removed, 2);
+		assert.strictEqual((await get('/space/1', ownerToken)).cache, 'MISS');
+		assert.strictEqual((await get('/space/2', ownerToken)).cache, 'MISS');
+	});
+
+	it("a tenant scoped entry is shared by users, and removed without a user", async () => {
+		await get('/catalog', ownerToken);
+		await settle();
+		assert.strictEqual((await get('/catalog', secondToken)).cache, 'HIT');
+		let outcome = await invalidate({ "tenant": tenantId, "service": "spaces", "api": "GET /catalog" });
+		assert.strictEqual(outcome.body.data.removed, 1);
+		assert.strictEqual((await get('/catalog', secondToken)).cache, 'MISS');
+	});
+
+	it("a request that started before the invalidation is not stored", async () => {
+		let inFlight = get('/slow', ownerToken);
+		await new Promise((r) => setTimeout(r, 300));
+		let outcome = await invalidate({ "tenant": tenantId, "service": "spaces", "api": "GET /slow", "user": ownerId });
+		assert.strictEqual(outcome.status, 200);
+		let first = await inFlight;
+		assert.strictEqual(first.status, 200);
+		await settle();
+		let next = await get('/slow', ownerToken);
+		assert.strictEqual(next.cache, 'MISS');
+		assert.strictEqual(next.body.data.call, first.body.data.call + 1);
+		await settle();
+		assert.strictEqual((await get('/slow', ownerToken)).cache, 'HIT');
+	});
+
+	it("refuses an invalid request", async () => {
+		assert.strictEqual((await invalidate({ "service": "spaces" })).status, 400);
+		assert.strictEqual((await invalidate({ "tenant": tenantId, "service": "spaces", "api": "/spaces" })).status, 400);
+		let wrongMethod = await invalidate(undefined, 'GET');
+		assert.strictEqual(wrongMethod.status, 405);
+		assert.strictEqual(wrongMethod.body.result, false);
+	});
+
+	after((done) => {
+		mockServers.sAppServer.close();
+		mockServers.mAppServer.close();
+		c.stop(registry, log, service, server, serverMaintenance, () => {
+			done();
+		});
+	});
+});

package/test/integration/index.js

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

package/test/unit/index.js

@@ -39,8 +39,11 @@ 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/cache/mongo.js");
+        require("./mw/cache/invalidate.js");
         require("./mw/lastSeen/index.js");
 
         require("./utilities/utils.js");

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

@@ -575,4 +575,126 @@ describe("Unit test for: mw - cache", () => {
 		});
 	});
 
+	describe("what an invalidation matches on", () => {
+		let noopRes = {
+			setHeader: function() {},
+			writeHead: function() { return this; },
+			write: function() { return true; },
+			end: function() {}
+		};
+
+		function buildReq(path, isAPIPublic, apis) {
+			return {
+				method: 'GET',
+				query: { page: '2' },
+				soajs: {
+					tenant: { id: 'tenant-meta' },
+					uracDriver: { id: 'user-7' },
+					controller: {
+						serviceParams: { name: 'spaces', serviceInfo: ['', 'spaces'].concat(path.split('/').slice(1)), isAPIPublic: isAPIPublic }
+					},
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									cache: {
+										model: 'memory',
+										services: {
+											spaces: { enabled: true, apis: apis }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+		}
+
+		it("records the service, the api as configured and the user", (done) => {
+			let before = Date.now();
+			let req = buildReq('/space/42', false, { 'GET /space/:id': { enabled: true } });
+			mw(mockConfig)(req, noopRes, (error) => {
+				assert.ifError(error);
+				let meta = req.soajs.cacheContext.meta;
+				assert.strictEqual(meta.service, 'spaces');
+				assert.strictEqual(meta.api, 'GET /space/:id');
+				assert.strictEqual(meta.user, 'user-7');
+				assert.ok(meta.startedAt >= before && meta.startedAt <= Date.now());
+				done();
+			});
+		});
+
+		it("records no user for a tenant scoped api", (done) => {
+			let req = buildReq('/catalog', false, { 'GET /catalog': { enabled: true, scope: 'tenant' } });
+			mw(mockConfig)(req, noopRes, (error) => {
+				assert.ifError(error);
+				assert.strictEqual(req.soajs.cacheContext.meta.api, 'GET /catalog');
+				assert.strictEqual(req.soajs.cacheContext.meta.user, null);
+				done();
+			});
+		});
+	});
+
+	describe("the access token is not part of the key", () => {
+		let noopRes = {
+			setHeader: function() {},
+			writeHead: function() { return this; },
+			write: function() { return true; },
+			end: function() {}
+		};
+
+		function buildReq(query, userId) {
+			return {
+				method: 'GET',
+				query: query,
+				soajs: {
+					tenant: { id: 'tenant-token' },
+					uracDriver: { id: userId },
+					controller: { serviceParams: { name: 'test', serviceInfo: ['', 'test', 'catalog'], isAPIPublic: true } },
+					registry: {
+						custom: {
+							gateway: {
+								value: {
+									cache: {
+										model: 'memory',
+										services: {
+											test: { enabled: true, apis: { 'GET /catalog': { enabled: true, scope: 'tenant' } } }
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+		}
+
+		function keyOf(query, userId) {
+			return new Promise((resolve) => {
+				let req = buildReq(query, userId);
+				mw(mockConfig)(req, noopRes, () => {
+					resolve(req.soajs.cacheContext.key.l2);
+				});
+			});
+		}
+
+		it("two users with their own tokens share a tenant scoped entry", async () => {
+			let ann = await keyOf({ access_token: 'AAA', page: '1' }, 'ann');
+			let bob = await keyOf({ access_token: 'BBB', page: '1' }, 'bob');
+			assert.strictEqual(ann, bob);
+		});
+
+		it("a token alone gives the same key as no query", async () => {
+			let withToken = await keyOf({ access_token: 'AAA' }, 'ann');
+			let without = await keyOf({}, 'ann');
+			assert.strictEqual(withToken, without);
+		});
+
+		it("the other query params still make the key", async () => {
+			let one = await keyOf({ access_token: 'AAA', page: '1' }, 'ann');
+			let two = await keyOf({ access_token: 'AAA', page: '2' }, 'ann');
+			assert.notStrictEqual(one, two);
+		});
+	});
 });

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

@@ -0,0 +1,99 @@
+"use strict";
+
+const helper = require("../../../helper.js");
+const invalidate = helper.requireModule('./mw/cache/invalidate');
+const model = helper.requireModule('./mw/cache/model/mongo');
+const assert = require('assert');
+
+describe("Unit test for: mw - cache invalidate", () => {
+
+	let received = null;
+	let failure = null;
+	let originalInvalidateMatching = null;
+	let originalMongo = null;
+
+	function registry(model) {
+		return { custom: { gateway: { value: { cache: { model: model, services: {} } } } } };
+	}
+
+	before(() => {
+		originalInvalidateMatching = model.invalidateMatching;
+		originalMongo = model.mongo;
+		model.mongo = {};
+		model.invalidateMatching = async (criteria) => {
+			received = criteria;
+			if (failure) {
+				throw failure;
+			}
+			return 2;
+		};
+	});
+	after(() => {
+		model.invalidateMatching = originalInvalidateMatching;
+		model.mongo = originalMongo;
+	});
+	beforeEach(() => {
+		received = null;
+		failure = null;
+	});
+
+	it("removes the matching entries", async () => {
+		let outcome = await invalidate(registry('mongo'), { tenant: 't1', service: 'spaces', api: 'GET /spaces', user: 'u1' });
+		assert.deepStrictEqual(outcome, { status: 200, removed: 2 });
+		assert.deepStrictEqual(received, { tenant: 't1', service: 'spaces', api: 'GET /spaces', user: 'u1' });
+	});
+
+	it("api and user are optional", async () => {
+		let outcome = await invalidate(registry('mongo'), { tenant: 't1', service: 'spaces' });
+		assert.strictEqual(outcome.status, 200);
+		assert.deepStrictEqual(received, { tenant: 't1', service: 'spaces', api: undefined, user: undefined });
+	});
+
+	it("refuses the memory model", async () => {
+		let outcome = await invalidate(registry('memory'), { tenant: 't1', service: 'spaces' });
+		assert.strictEqual(outcome.status, 400);
+		assert.ok(outcome.error.indexOf('mongo') !== -1);
+		assert.strictEqual(received, null);
+	});
+
+	it("refuses when no model is set, memory is the default", async () => {
+		let outcome = await invalidate(registry(undefined), { tenant: 't1', service: 'spaces' });
+		assert.strictEqual(outcome.status, 400);
+		assert.strictEqual(received, null);
+	});
+
+	it("refuses when caching is not configured", async () => {
+		let outcome = await invalidate({ custom: {} }, { tenant: 't1', service: 'spaces' });
+		assert.strictEqual(outcome.status, 400);
+	});
+
+	it("requires tenant and service", async () => {
+		assert.strictEqual((await invalidate(registry('mongo'), null)).status, 400);
+		assert.strictEqual((await invalidate(registry('mongo'), { service: 'spaces' })).status, 400);
+		assert.strictEqual((await invalidate(registry('mongo'), { tenant: 't1' })).status, 400);
+		assert.strictEqual(received, null);
+	});
+
+	it("requires the api as written in the configuration", async () => {
+		assert.strictEqual((await invalidate(registry('mongo'), { tenant: 't1', service: 'spaces', api: '/spaces' })).status, 400);
+		assert.strictEqual((await invalidate(registry('mongo'), { tenant: 't1', service: 'spaces', api: 'POST /spaces' })).status, 400);
+		assert.strictEqual((await invalidate(registry('mongo'), { tenant: 't1', service: 'spaces', user: 42 })).status, 400);
+		assert.strictEqual(received, null);
+	});
+
+	it("answers 500 when the store fails", async () => {
+		failure = new Error("down");
+		let outcome = await invalidate(registry('mongo'), { tenant: 't1', service: 'spaces' });
+		assert.strictEqual(outcome.status, 500);
+	});
+
+	it("answers 500 when the store is not ready", async () => {
+		model.mongo = null;
+		try {
+			let outcome = await invalidate(registry('mongo'), { tenant: 't1', service: 'spaces' });
+			assert.strictEqual(outcome.status, 500);
+		} finally {
+			model.mongo = {};
+		}
+	});
+});