@webda/core
Version:
Expose API with Lambda
192 lines • 7.41 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var MemoryQueueTest_1;
import { suite, test } from "@testdeck/mocha";
import * as assert from "assert";
import { register } from "prom-client";
import { MemoryQueue } from "./memoryqueue.js";
import { QueueTest } from "./queue.spec.js";
class Title {
constructor(title) {
this.title = title;
}
}
let MemoryQueueTest = MemoryQueueTest_1 = class MemoryQueueTest extends QueueTest {
async receiveMessage(proto) {
MemoryQueueTest_1.seq++;
switch (MemoryQueueTest_1.seq) {
case 1:
// Test the resume if no messages available
return [];
case 2:
return [
{
ReceiptHandle: "msg1",
Message: MemoryQueueTest_1.queue.unserialize(JSON.stringify({ title: "plop" }), proto)
}
];
case 3:
throw Error();
case 4:
// An error occured it should double the pause
MemoryQueueTest_1.failedIterations.push(
// @ts-ignore
MemoryQueueTest_1.queue.failedIterations);
return Promise.resolve([
{
ReceiptHandle: "msg2",
Message: MemoryQueueTest_1.queue.unserialize(JSON.stringify({ title: "plop2" }), proto)
}
]);
case 5:
// Error on callback dont generate a double delay
MemoryQueueTest_1.failedIterations.push(
// @ts-ignore
MemoryQueueTest_1.queue.failedIterations);
MemoryQueueTest_1.resolve(MemoryQueueTest_1.workerPromise.cancel());
return [];
}
}
async receiveMessageParallelism(proto) {
MemoryQueueTest_1.seq++;
switch (MemoryQueueTest_1.seq) {
case 1:
return [
{
ReceiptHandle: "msg1",
Message: { title: "plop" }
},
{
ReceiptHandle: "msg2",
Message: { title: "plop2" }
}
];
case 2:
MemoryQueueTest_1.resolve(MemoryQueueTest_1.workerPromise.cancel());
return [];
}
}
async worker() {
MemoryQueueTest_1.failedIterations = [];
await new Promise(resolve => {
MemoryQueueTest_1.resolve = resolve;
let queue = new MemoryQueue(this.webda, "q", {
workerParallelism: false
});
queue.initMetrics();
MemoryQueueTest_1.queue = queue;
// @ts-ignore
queue.delayer = () => 1;
MemoryQueueTest_1.seq = 0;
// @ts-ignore
queue._webda = {
log: () => { }
};
queue.receiveMessage = this.receiveMessage.bind(queue);
queue.deleteMessage = async (handle) => {
// Should only have the msg1 handle in deleteMessage as msg2 is fake error
assert.strictEqual(handle, "msg1");
};
let callback = async (event) => {
switch (MemoryQueueTest_1.seq) {
case 2:
assert.strictEqual(event.title, "plop");
return;
case 4:
// Simulate error in callback
throw Error();
}
};
MemoryQueueTest_1.workerPromise = queue.consume(callback, Title);
});
assert.deepStrictEqual(MemoryQueueTest_1.failedIterations, [1, 0]);
}
async parallelized() {
let op = 0;
const run = async (parallel) => {
await new Promise(resolve => {
let queue = new MemoryQueue(this.webda, "q", {
workerParallelism: parallel
});
queue.initMetrics();
MemoryQueueTest_1.queue = queue;
MemoryQueueTest_1.resolve = resolve;
// @ts-ignore
queue.delayer = () => 1;
MemoryQueueTest_1.seq = 0;
// @ts-ignore
queue._webda = {
log: () => { }
};
queue.receiveMessage = this.receiveMessageParallelism.bind(queue);
queue.deleteMessage = async (handle) => { };
let callback = async (event) => {
if (event.title === "plop") {
await this.sleep(300);
op = 1;
}
else {
await this.sleep(100);
op *= 2;
}
};
MemoryQueueTest_1.workerPromise = queue.consume(callback, undefined);
});
};
await run(true);
assert.strictEqual(op, 1, 'It should have been run in parallel so op=0 as *2 will happen before =1"');
await run(false);
assert.strictEqual(op, 2, 'It should have been run in parallel so op=2 as *2 will happen after =1"');
}
async basic() {
let queue = this.getService("MemoryQueue");
// For coverage
assert.strictEqual(queue.getParameters().expire, 1000, "1s should be convert to ms");
queue.getParameters().expire = undefined;
await queue.reinit({});
assert.strictEqual(queue.getParameters().expire, 30000, "default should be 30s");
queue.getParameters().expire = 1000;
queue.__clean();
// Should not have issue with unknown receipt
queue.deleteMessage("bouzouf");
assert.strictEqual((await queue.receiveMessage()).length, 0);
return this.simple(queue);
}
async uuid() {
let queue = this.getService("MemoryQueue");
let first = true;
let callCount = 0;
// @ts-ignore
queue._queue = new Proxy(queue._queue, {
get: (q, prop) => {
callCount += 1;
if (callCount === 1) {
return "plop";
}
}
});
await queue.sendMessage({});
assert.strictEqual(callCount, 2);
await register.metrics();
}
};
__decorate([
test
], MemoryQueueTest.prototype, "worker", null);
__decorate([
test
], MemoryQueueTest.prototype, "parallelized", null);
__decorate([
test
], MemoryQueueTest.prototype, "basic", null);
__decorate([
test
], MemoryQueueTest.prototype, "uuid", null);
MemoryQueueTest = MemoryQueueTest_1 = __decorate([
suite
], MemoryQueueTest);
//# sourceMappingURL=memoryqueue.spec.js.map