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

MyTmpVpn Client Library

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const loglevel_1 = __importDefault(require("loglevel"));
const vpnlib = __importStar(require("@mytmpvpn/mytmpvpn-common/models/vpn"));
const appconfig = __importStar(require("../src/appconfig"));
const common_1 = require("./common");
const auth_1 = require("../src/auth");
describe('Testing createVpn APIs', () => {
    let client;
    const appConfig = appconfig.loadDefaultAppConfig();
    const userProfile = (0, auth_1.createTestUserProfile)();
    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_GEONAMES_ID, vpnConfig);
        loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
        expect(newVpn).toBeDefined();
        expect(newVpn.geonamesId).toEqual(common_1.VPN_GEONAMES_ID);
        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_GEONAMES_ID, {
            maxPeanuts: -1,
            type: vpnlib.VpnType.WireGuard
        });
        loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
        expect(newVpn).toBeDefined();
        expect(newVpn.geonamesId).toEqual(common_1.VPN_GEONAMES_ID);
        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_GEONAMES_ID, {
            maxPeanuts: 0,
            type: vpnlib.VpnType.WireGuard
        });
        loglevel_1.default.debug(`vpn returned: ${JSON.stringify(newVpn)}`);
        expect(newVpn).toBeDefined();
        expect(newVpn.geonamesId).toEqual(common_1.VPN_GEONAMES_ID);
        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_GEONAMES_ID, 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.error).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_GEONAMES_ID, {
                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.error).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_GEONAMES_ID, {
                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.error).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_GEONAMES_ID, {
                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.error).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_GEONAMES_ID, {
                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.error).toContain(`deleteAfter must be lesser than `);
        }
    });
    it("should reach quota on maximum number of Vpns that can be created", async () => {
        const locationsNb = (await client.listLocations()).length;
        const vpns = await client.listVpns();
        expect(vpns).toBeDefined();
        const orginalLengths = vpns.length;
        const runningVpns = vpns.filter(vpn => [
            vpnlib.VpnState.Creating,
            vpnlib.VpnState.Created,
            vpnlib.VpnState.Provisioning,
            vpnlib.VpnState.Running
        ]
            .includes(vpn.state));
        loglevel_1.default.debug(`runningVpns: ${JSON.stringify(runningVpns)}`);
        const vpnConfig = (0, common_1.getMaxPeanutsConfig)(await client.getVpnConfigLimits());
        const allowed = (await client.getUserConfig()).vpnsQuota - runningVpns.length;
        const succeded = [];
        for (let i = 0; i < allowed; i++) {
            const vpn = await client.createVpn(common_1.VPN_GEONAMES_ID, 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_GEONAMES_ID, 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.error).toContain('Quota reached');
        }
        // Let's clean-up here
        await client.waitAndDeleteAll(succeded.map(vpn => vpn.vpnId));
    });
});