@mytmpvpn/mytmpvpn-client/dist/test/create.test.js

MyTmpVpn Client Library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const loglevel_1 = require("loglevel");
const vpnlib = require("@mytmpvpn/mytmpvpn-common/models/vpn");
const appconfig = require("../src/appconfig");
const common_1 = require("./common");
describe('Testing createVpn APIs', () => {
    var client;
    const appConfig = appconfig.loadDefaultAppConfig();
    const userProfile = (0, common_1.createUserProfile)();
    beforeAll(async () => {
        client = await (0, common_1.createAuthUser)(appConfig, userProfile);
    }, 600000);
    afterAll(async () => {
        await (0, common_1.deleteCleanUpAllAndDeleteAuthUser)(client, appConfig, userProfile);
    }, 600000);
    it("should create one new vpn for a given user with minimum number of peanuts", async () => {
        const vpnConfigLimits = await client.getVpnConfigLimits();
        const vpnConfig = (0, common_1.getGoodPeanutsConfig)(vpnConfigLimits);
        const newVpn = await client.createVpn(common_1.VPN_REGION, vpnConfig);
        loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
        expect(newVpn).toBeDefined();
        expect(newVpn.region).toEqual(common_1.VPN_REGION);
        expect(newVpn.state).toBeDefined();
        expect([vpnlib.VpnState.Creating, vpnlib.VpnState.Created, vpnlib.VpnState.Provisioning].includes(newVpn.state));
        expect(vpnlib.toRank(newVpn.state) >= vpnlib.toRank(vpnlib.VpnState.Creating)).toBe(true);
        const newVpns = await client.listVpns();
        expect(newVpns.map(vpn => vpn.vpnId)).toContainEqual(newVpn.vpnId);
        await (0, common_1.cleanUp)(client, newVpn);
    });
    it("should create one new vpn for a given user with number of peanuts set to -1 and enough peanuts in the account", async () => {
        const newVpn = await client.createVpn(common_1.VPN_REGION, {
            maxPeanuts: -1,
            type: vpnlib.VpnType.WireGuard
        });
        loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
        expect(newVpn).toBeDefined();
        expect(newVpn.region).toEqual(common_1.VPN_REGION);
        expect(newVpn.state).toBeDefined();
        expect([vpnlib.VpnState.Creating, vpnlib.VpnState.Created, vpnlib.VpnState.Provisioning].includes(newVpn.state));
        expect(vpnlib.toRank(newVpn.state) >= vpnlib.toRank(vpnlib.VpnState.Creating)).toBe(true);
        const newVpns = await client.listVpns();
        loglevel_1.default.debug(`vpns returned: ${JSON.stringify(newVpns)}`);
        expect(newVpns.map(vpn => vpn.vpnId)).toContainEqual(newVpn.vpnId);
        await (0, common_1.cleanUp)(client, newVpn);
    });
    it("should create one new vpn for a given user with number of peanuts set to 0 and enough peanuts in the account", async () => {
        const newVpn = await client.createVpn(common_1.VPN_REGION, {
            maxPeanuts: 0,
            type: vpnlib.VpnType.WireGuard
        });
        loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
        expect(newVpn).toBeDefined();
        expect(newVpn.region).toEqual(common_1.VPN_REGION);
        expect(newVpn.state).toBeDefined();
        expect([vpnlib.VpnState.Creating, vpnlib.VpnState.Created, vpnlib.VpnState.Provisioning].includes(newVpn.state));
        expect(vpnlib.toRank(newVpn.state) >= vpnlib.toRank(vpnlib.VpnState.Creating)).toBe(true);
        const newVpns = await client.listVpns();
        expect(newVpns.map(vpn => vpn.vpnId)).toContainEqual(newVpn.vpnId);
        await (0, common_1.cleanUp)(client, newVpn);
    });
    it("should not create a vpn if given peanuts is less than minimum", async () => {
        const vpnConfigLimits = await client.getVpnConfigLimits();
        try {
            const vpnConfig = (0, common_1.getTooFewPeanutsConfig)(vpnConfigLimits);
            const newVpn = await client.createVpn(common_1.VPN_REGION, vpnConfig);
            loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
            fail("Should not reach here");
        }
        catch (err) {
            expect(err).not.toEqual("Should not reach here");
            expect(err.response).toBeDefined(),
                `Expected err.response to be defined. Received error: ${JSON.stringify(err)}`;
            expect(err.response.status).toBeDefined();
            expect(err.response.data).toBeDefined();
            expect(err.response.status).toBe(400);
            expect(err.response.data).toContain("Minimum number of peanuts should be");
        }
    });
    it("should not create a vpn if given peanuts is more that the current balance", async () => {
        const balance = await client.getPeanutsBalance();
        try {
            const newVpn = await client.createVpn(common_1.VPN_REGION, {
                maxPeanuts: balance * 10,
                type: vpnlib.VpnType.WireGuard
            });
            loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
            fail("Should not reach here");
        }
        catch (err) {
            expect(err).not.toEqual("Should not reach here");
            expect(err.response).toBeDefined();
            expect(err.response.status).toBeDefined();
            expect(err.response.data).toBeDefined();
            expect(err.response.status).toBe(400);
            expect(err.response.data).toContain(`Not enough peanuts, you specified: `);
        }
    });
    it("should not create a vpn if deleteAfter is in the past", async () => {
        try {
            const newVpn = await client.createVpn(common_1.VPN_REGION, {
                maxPeanuts: -1,
                type: vpnlib.VpnType.WireGuard,
                deleteAfter: -5 * 60
            });
            loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
            fail("Should not reach here");
        }
        catch (err) {
            expect(err).not.toEqual("Should not reach here");
            expect(err.response).toBeDefined();
            expect(err.response.status).toBeDefined();
            expect(err.response.data).toBeDefined();
            expect(err.response.status).toBe(400);
            expect(err.response.data).toContain(`deleteAfter must be greater than `);
        }
    });
    it("should not create a vpn if deleteAfter is not in the future enough", async () => {
        try {
            const vpnConfigLimits = await client.getVpnConfigLimits();
            const newVpn = await client.createVpn(common_1.VPN_REGION, {
                maxPeanuts: -1,
                type: vpnlib.VpnType.WireGuard,
                deleteAfter: vpnConfigLimits.deleteAfterFieldMinValue / 2
            });
            loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
            fail("Should not reach here");
        }
        catch (err) {
            expect(err).not.toEqual("Should not reach here");
            expect(err.response).toBeDefined();
            expect(err.response.status).toBeDefined();
            expect(err.response.data).toBeDefined();
            expect(err.response.status).toBe(400);
            expect(err.response.data).toContain(`deleteAfter must be greater than `);
        }
    });
    it("should not create a vpn if deleteAfter is too far in the future", async () => {
        try {
            const vpnConfigLimits = await client.getVpnConfigLimits();
            const newVpn = await client.createVpn(common_1.VPN_REGION, {
                maxPeanuts: -1,
                type: vpnlib.VpnType.WireGuard,
                deleteAfter: vpnConfigLimits.deleteAfterFieldMaxValue * 2
            });
            loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
            fail("Should not reach here");
        }
        catch (err) {
            expect(err).not.toEqual("Should not reach here");
            expect(err.response).toBeDefined();
            expect(err.response.status).toBeDefined();
            expect(err.response.data).toBeDefined();
            expect(err.response.status).toBe(400);
            expect(err.response.data).toContain(`deleteAfter must be lesser than `);
        }
    });
    it("should reach quota on maximum number of Vpns that can be created", async () => {
        const regionsNb = (await client.listRegions()).length;
        const vpns = await client.listVpns();
        expect(vpns).toBeDefined();
        const orginalLengths = vpns.length;
        const runningVpns = vpns.filter(vpn => vpn.state == vpnlib.VpnState.Running);
        loglevel_1.default.debug(`runningVpns: ${JSON.stringify(runningVpns)}`);
        const vpnConfig = (0, common_1.getMaxPeanutsConfig)(await client.getVpnConfigLimits());
        // Default quota for testing is 2 * number of regions
        const allowed = 2 * (regionsNb - runningVpns.length);
        const succeded = [];
        for (let i = 0; i < allowed; i++) {
            const vpn = await client.createVpn(common_1.VPN_REGION, vpnConfig);
            loglevel_1.default.debug(`vpn returned: ${JSON.stringify(vpn)}`);
            expect(vpn).toBeDefined();
            succeded.push(vpn);
        }
        loglevel_1.default.log(`Number of created vpns: ${JSON.stringify(succeded.length)}`);
        try {
            const unexpectedVpn = await client.createVpn(common_1.VPN_REGION, vpnConfig);
            loglevel_1.default.debug(`unexpectedVpn: ${JSON.stringify(unexpectedVpn)}`);
            fail("Should not reach here");
        }
        catch (err) {
            expect(err).not.toEqual("Should not reach here");
            const util = require('util');
            // Provide a clear message that inspect the error if err.response is not defined
            if (err.response == undefined) {
                loglevel_1.default.log(`err: ${util.inspect(err, { showHidden: false, depth: null })}`);
            }
            expect(err.response).toBeDefined();
            expect(err.response.status).toBeDefined();
            expect(err.response.data).toBeDefined();
            expect(err.response.status).toBe(400);
            expect(err.response.data).toContain('Quota reached');
        }
        // Let's clean-up here
        await client.waitAndDeleteAll(succeded.map(vpn => vpn.vpnId));
    });
});