@webda/aws/lib/services/sqsqueue.spec.js

Webda AWS Services implementation

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;
};
import { PurgeQueueCommand, SQS } from "@aws-sdk/client-sqs";
import { suite, test, timeout } from "@testdeck/mocha";
import { getCommonJS } from "@webda/core";
import { QueueTest } from "@webda/core/lib/queues/queue.spec.js";
import * as assert from "assert";
import { mockClient } from "aws-sdk-client-mock";
import * as path from "path";
import { checkLocalStack, defaultCreds } from "../index.spec.js";
import { SQSQueue } from "./sqsqueue.js";
const { __dirname } = getCommonJS(import.meta.url);
let SQSQueueTest = class SQSQueueTest extends QueueTest {
    async before() {
        process.env.AWS_ACCESS_KEY_ID = "plop";
        process.env.AWS_SECRET_ACCESS_KEY = "plop";
        process.env.AWS_DEFAULT_REGION = "us-east-1";
        await checkLocalStack();
        await super.before();
        await this.install();
    }
    async tweakApp(app) {
        super.tweakApp(app);
        app.addService("test/awsevents", (await import(path.join(__dirname, ..."../../test/moddas/awsevents.js".split("/")))).default);
    }
    async install() {
        var sqs = new SQS({
            endpoint: "http://localhost:4566",
            credentials: defaultCreds,
            region: "us-east-1"
        });
        try {
            this.info = await sqs.getQueueUrl({
                QueueName: "webda-test",
                QueueOwnerAWSAccountId: "000000000000"
            });
        }
        catch (err) {
            await sqs.createQueue({
                QueueName: "webda-test"
            });
            this.info = await sqs.getQueueUrl({
                QueueName: "webda-test",
                QueueOwnerAWSAccountId: "000000000000"
            });
        }
        try {
            this.info = await sqs.getQueueUrl({
                QueueName: "webda-test2.fifo",
                QueueOwnerAWSAccountId: "000000000000"
            });
        }
        catch (err) {
            await sqs.createQueue({
                QueueName: "webda-test2.fifo",
                Attributes: {
                    FifoQueue: "true"
                }
            });
            this.info = await sqs.getQueueUrl({
                QueueName: "webda-test2.fifo",
                QueueOwnerAWSAccountId: "000000000000"
            });
        }
    }
    async basic() {
        let queue = this.webda.getService("SQSQueue");
        queue.getParameters().queue = "http://localhost:4566/000000000000/webda-test";
        await queue.__clean();
        // Update timeout to 80000ms as Purge can only be sent once every 60s
        await this.simple(queue, true);
        queue.getParameters().CloudFormationSkip = true;
        assert.deepStrictEqual(queue.getCloudFormation(null), {});
    }
    async fifo() {
        let queue = this.webda.getService("SQSQueue");
        queue.getParameters().queue = "http://localhost:4566/000000000000/webda-test2.fifo";
        queue.getParameters().MessageGroupId = "myGroup";
        await queue.sendMessage({});
    }
    ARN() {
        let queue = this.webda.getService("SQSQueue");
        let arn = queue.getARNPolicy();
        assert.strictEqual(arn.Action.indexOf("sqs:SendMessage") >= 0, true);
        assert.strictEqual(arn.Resource[0], "arn:aws:sqs:us-east-1:000000000000:webda-test");
    }
    getQueueInfos() {
        let queue = this.webda.getService("SQSQueue");
        queue.getParameters().queue = "none";
        let error = false;
        try {
            let info = queue._getQueueInfosFromUrl();
        }
        catch (ex) {
            error = true;
        }
        assert.strictEqual(error, true);
    }
    async purgeQueueError() {
        let queue = this.webda.getService("SQSQueue");
        let mock = mockClient(SQS)
            .on(PurgeQueueCommand)
            .callsFake(async () => {
            let error = new Error("AWS.SimpleQueueService.PurgeQueueInProgress");
            error.name = "AWS.SimpleQueueService.PurgeQueueInProgress";
            error.retryDelay = 1;
            throw error;
        });
        await assert.rejects(() => queue.__clean(), /AWS.SimpleQueueService.PurgeQueueInProgress/);
        mock.restore();
        mock = mockClient(SQS)
            .on(PurgeQueueCommand)
            .callsFake(async () => {
            throw new Error("Other");
        });
        await assert.rejects(() => queue.__clean(), /Other/);
        mock.restore();
    }
    getMaxConsumers() {
        let queue = new SQSQueue(this.webda, "plop", { maxConsumers: 30 });
        assert.strictEqual(queue.getMaxConsumers(), 3);
        queue.getParameters().maxConsumers = 3;
        assert.strictEqual(queue.getMaxConsumers(), 1);
    }
};
__decorate([
    test,
    timeout(80000)
], SQSQueueTest.prototype, "basic", null);
__decorate([
    test
], SQSQueueTest.prototype, "fifo", null);
__decorate([
    test
], SQSQueueTest.prototype, "ARN", null);
__decorate([
    test
], SQSQueueTest.prototype, "getQueueInfos", null);
__decorate([
    test
], SQSQueueTest.prototype, "purgeQueueError", null);
__decorate([
    test
], SQSQueueTest.prototype, "getMaxConsumers", null);
SQSQueueTest = __decorate([
    suite
], SQSQueueTest);
//# sourceMappingURL=sqsqueue.spec.js.map