@webda/gcp/lib/services/pubsub.spec.js

Webda GCP 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 { PubSub } from "@google-cloud/pubsub";
import { suite, test } from "@testdeck/mocha";
import { Core, WaitFor, WaitLinearDelay } from "@webda/core";
import { WebdaTest } from "@webda/core/lib/test.js";
import * as assert from "assert";
import * as sinon from "sinon";
let GCPPubSubTest = class GCPPubSubTest extends WebdaTest {
    constructor() {
        super(...arguments);
        this.subscriptions = [];
    }
    async after() {
        await super.after();
        const pubsub = new PubSub();
        for (let subscription of this.subscriptions) {
            try {
                const [exists] = await pubsub.subscription(subscription).exists();
                if (exists) {
                    await pubsub.subscription(subscription).delete();
                }
            }
            catch (err) { }
        }
    }
    async basic() {
        let pubsub = this.webda.getService("pubsub");
        let subscriptionCount = 1;
        assert.strictEqual(pubsub.getSubscriptionName(), `${pubsub.getName()}-${Core.getMachineId()}`);
        sinon.stub(pubsub, "getSubscriptionName").callsFake(() => {
            const name = `test-${Core.getMachineId()}-${subscriptionCount++}`;
            this.subscriptions.push(name);
            return name;
        });
        let counter = 0;
        let consumers = [];
        let subscription;
        await new Promise((resolve, reject) => {
            consumers.push(pubsub.consume(async (evt) => {
                counter++;
            }));
            consumers.push(pubsub.consume(async (evt) => {
                counter++;
                throw new Error("Should not fail");
            }, undefined, sub => {
                subscription = sub;
                resolve();
            }));
        });
        await pubsub.sendMessage("plop");
        // This is not logical w/o subscription value
        assert.strictEqual(await pubsub.size(), 0);
        await WaitFor(async (resolve) => {
            if (counter === 2) {
                resolve();
                return true;
            }
            return false;
        }, 10, "Events", undefined, WaitLinearDelay(1000));
        // We might have concurrence in unit test
        assert.ok(counter >= 2);
        subscription.emit("error", "Fake server error");
        await assert.rejects(() => consumers[1], /Fake server error/);
        await consumers[0].cancel();
        // Hack our way to test exception within the main loop
        let stub = sinon.stub(pubsub.pubsub, "subscription").callsFake(() => {
            throw new Error("Bad code?");
        });
        // Should reject
        await assert.rejects(() => pubsub.consume(async (evt) => {
            counter++;
        }), /Bad code\?/);
        stub.restore();
    }
};
__decorate([
    test
], GCPPubSubTest.prototype, "basic", null);
GCPPubSubTest = __decorate([
    suite
], GCPPubSubTest);
//# sourceMappingURL=pubsub.spec.js.map