spec-3nweb-server 1.8.5 → 1.8.7

package/build/tests/libs-for-tests/server-components/component.js

@@ -0,0 +1,77 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = void 0;
+const server_runner_1 = require("../server-runner");
+const async_fs_node_1 = require("../../../lib-common/async-fs-node");
+const services_1 = require("../../../services");
+const dns_1 = require("../../../mock/dns");
+const dns = require("dns");
+const app_1 = require("../../../lib-server/web-sockets/app");
+const path_1 = require("path");
+const signup_tokens_1 = require("../../../signup/signup-tokens");
+const DEFAULT_SERVICE_PORT = 8088;
+const DEFAULT_DATA_FOLDER = (0, path_1.join)(__dirname, '/../../../../test-data');
+class Component extends server_runner_1.ServerRunner {
+    constructor(conf, signupDomains, servicePort = DEFAULT_SERVICE_PORT, dataFolder = DEFAULT_DATA_FOLDER) {
+        super(servicePort);
+        this.conf = conf;
+        this.signupDomains = signupDomains;
+        this.dataFolder = dataFolder;
+        this.conf.rootFolder = this.dataFolder;
+        this.conf.signup.noTokenFile = (0, path_1.join)(this.dataFolder, 'no-tokens-signup.json');
+        if (this.conf.mailerId) {
+            const certs = this.conf.mailerId.certs;
+            this.conf.mailerId.certs = (0, path_1.join)(this.dataFolder, (certs ? certs : 'mid-certs.json'));
+        }
+        const urlWithoutProto = this.url.substring(this.url.indexOf('://') + 3);
+        this.dns = new dns_1.DNSMock(urlWithoutProto + 'mailerid/');
+    }
+    async prepToRun() {
+        // prepare data folders
+        try {
+            await (0, async_fs_node_1.mkdir)(this.dataFolder);
+            // write to-tokens signup file
+            const noTokenCtx = (0, signup_tokens_1.makeMultiDomainSignupCtx)(this.signupDomains);
+            await (0, async_fs_node_1.writeFile)(this.conf.signup.noTokenFile, JSON.stringify(noTokenCtx), { encoding: 'utf8' });
+        }
+        catch (exc) {
+            if (!exc.alreadyExists) {
+                throw exc;
+            }
+        }
+        // inject dns mock
+        dns.resolveTxt = this.dns.resolveTxt;
+        // setup servers
+        const app = new app_1.AppWithWSs();
+        app.use((0, services_1.accountsApp)(this.conf));
+        app.use((0, services_1.servicesApp)(this.conf));
+        return app;
+    }
+    async clean() {
+        await (0, async_fs_node_1.rmDirWithContent)(this.dataFolder).catch((exc) => {
+            if (!exc.notFound) {
+                throw exc;
+            }
+        });
+    }
+}
+exports.Component = Component;
+Object.freeze(Component.prototype);
+Object.freeze(Component);
+Object.freeze(exports);

package/build/tests/libs-for-tests/server-components/mailerid.d.ts

@@ -0,0 +1,10 @@
+import { Component } from './component';
+import { User } from '../pkl';
+export declare function addUserIn(rootServerUrl: string, userId: string): Promise<User>;
+export declare class MailerIdComponent extends Component {
+    midServiceDomain: string;
+    constructor(signupDomains: string[], midServiceDomain: string);
+    addUser(userId: string): Promise<User>;
+    get midUrl(): string;
+    getProvUrl(): Promise<string>;
+}

package/build/tests/libs-for-tests/server-components/mailerid.js

@@ -0,0 +1,103 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailerIdComponent = exports.addUserIn = void 0;
+const component_1 = require("./component");
+const url_1 = require("url");
+const xhr_utils_1 = require("../xhr-utils");
+const signup = require("../../../lib-common/admin-api/signup");
+const random = require("../../../lib-common/random-node");
+const ecma_nacl_1 = require("ecma-nacl");
+const jwkeys_1 = require("../../../lib-common/jwkeys");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const mailerid_1 = require("../mailerid");
+async function addUserIn(rootServerUrl, userId) {
+    let reqOpts = {
+        url: (0, url_1.resolve)((0, url_1.resolve)(rootServerUrl, 'signup/'), signup.addUser.URL_END),
+        method: 'POST'
+    };
+    let user = {
+        id: userId,
+        loginDefaultSKey: await random.bytes(ecma_nacl_1.box.KEY_LENGTH),
+        loginLabeledSKey: {
+            k: await random.bytes(ecma_nacl_1.box.KEY_LENGTH),
+            kid: await random.stringOfB64Chars(12)
+        },
+        midUrl: undefined,
+        storageOwnerUrl: undefined
+    };
+    let req = {
+        userId: user.id,
+        storage: {
+            kdParams: {}
+        },
+        mailerId: {
+            defaultPKey: {
+                pkey: {
+                    alg: ecma_nacl_1.box.JWK_ALG_NAME,
+                    kid: '_',
+                    use: jwkeys_1.use.MID_PKLOGIN,
+                    k: buffer_utils_1.base64.pack(ecma_nacl_1.box.generate_pubkey(user.loginDefaultSKey))
+                },
+                kdParams: {}
+            },
+            otherPKeys: [{
+                    alg: ecma_nacl_1.box.JWK_ALG_NAME,
+                    kid: user.loginLabeledSKey.kid,
+                    use: jwkeys_1.use.MID_PKLOGIN,
+                    k: buffer_utils_1.base64.pack(ecma_nacl_1.box.generate_pubkey(user.loginLabeledSKey.k))
+                }]
+        }
+    };
+    let rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+    if (rep.status !== signup.addUser.SC.ok) {
+        throw new Error(`Fail to add user ${userId}`);
+    }
+    return user;
+}
+exports.addUserIn = addUserIn;
+class MailerIdComponent extends component_1.Component {
+    constructor(signupDomains, midServiceDomain) {
+        super({
+            rootFolder: null,
+            domain: midServiceDomain,
+            signup: {},
+            enabledServices: {
+                mailerId: true
+            },
+            mailerId: {
+                certs: null
+            }
+        }, signupDomains);
+        this.midServiceDomain = midServiceDomain;
+        Object.seal(this);
+    }
+    addUser(userId) {
+        return addUserIn(this.url, userId);
+    }
+    get midUrl() {
+        return (0, url_1.resolve)(this.url, 'mailerid/');
+    }
+    getProvUrl() {
+        return (0, mailerid_1.getProvPath)(this.midUrl);
+    }
+}
+exports.MailerIdComponent = MailerIdComponent;
+Object.freeze(MailerIdComponent.prototype);
+Object.freeze(MailerIdComponent);
+Object.freeze(exports);

package/build/tests/libs-for-tests/server-runner.d.ts

@@ -0,0 +1,15 @@
+import { AppWithWSs } from '../../lib-server/web-sockets/app';
+export type ServerState = 'stopped' | 'starting' | 'running' | 'stopping';
+export declare abstract class ServerRunner {
+    protected servicePort: number;
+    protected state: ServerState;
+    protected app: AppWithWSs;
+    constructor(servicePort: number);
+    abstract prepToRun(): Promise<AppWithWSs>;
+    abstract clean(): Promise<void>;
+    isRunning(): boolean;
+    start(): Promise<void>;
+    stop(doCleanup?: boolean): Promise<void>;
+    restart(): Promise<void>;
+    protected get url(): string;
+}

package/build/tests/libs-for-tests/server-runner.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerRunner = void 0;
+const https = require("https");
+const tls_options_1 = require("../../mock/tls-options");
+const processes_1 = require("../../lib-common/processes");
+// allow client test calls to trust above self-signed cert
+https.globalAgent.options.ca = tls_options_1.sslOpts.cert;
+class ServerRunner {
+    constructor(servicePort) {
+        this.servicePort = servicePort;
+        this.state = 'stopped';
+        this.app = undefined;
+    }
+    isRunning() {
+        return (this.state === 'running');
+    }
+    async start() {
+        if (this.state !== 'stopped') {
+            throw new Error(`Home server is already in ${this.state} state.`);
+        }
+        this.state = 'starting';
+        this.app = await this.prepToRun();
+        await this.app.start(tls_options_1.sslOpts, this.servicePort);
+        await (0, processes_1.sleep)(100);
+        this.state = 'running';
+    }
+    async stop(doCleanup = true) {
+        if (this.state !== 'running') {
+            throw new Error(`Home server is in ${this.state} state instead of running state`);
+        }
+        this.state = 'stopping';
+        await this.app.stop();
+        this.app = undefined;
+        if (doCleanup) {
+            await this.clean();
+        }
+        this.state = 'stopped';
+    }
+    async restart() {
+        if (this.isRunning()) {
+            await this.stop(false);
+        }
+        await this.start();
+    }
+    get url() {
+        return `https://localhost:${this.servicePort}/`;
+    }
+}
+exports.ServerRunner = ServerRunner;
+Object.freeze(ServerRunner.prototype);
+Object.freeze(ServerRunner);
+Object.freeze(exports);

package/build/tests/libs-for-tests/spec-assembly.d.ts

@@ -0,0 +1,6 @@
+export interface GenericSpecDescribe<TSetup> {
+    description: string;
+    definition?: (setup: () => TSetup) => (() => void);
+    focused?: boolean;
+}
+export declare function addSpecsFrom<TSetup>(specsFolder: string, setup: () => TSetup): void;

package/build/tests/libs-for-tests/spec-assembly.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSpecsFrom = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+function setupSpecs(specs, setup) {
+    if (!specs.definition) {
+        return;
+    }
+    if (specs.focused) {
+        fdescribe(specs.description, specs.definition(setup));
+    }
+    else {
+        describe(specs.description, specs.definition(setup));
+    }
+}
+function addSpecsFrom(specsFolder, setup) {
+    for (let fName of (0, fs_1.readdirSync)(specsFolder)) {
+        if (!fName.endsWith('.js')) {
+            continue;
+        }
+        let modPath = (0, path_1.join)(specsFolder, fName);
+        let specs = require(modPath).specs;
+        if (!specs) {
+            console.error(`Module ${fName} is not exposing specs objects with tests`);
+            continue;
+        }
+        if (Array.isArray(specs)) {
+            for (let s of specs) {
+                setupSpecs(s, setup);
+            }
+        }
+        else {
+            setupSpecs(specs, setup);
+        }
+    }
+}
+exports.addSpecsFrom = addSpecsFrom;
+Object.freeze(exports);

package/build/tests/libs-for-tests/ws-utils.d.ts

@@ -0,0 +1,3 @@
+import * as WebSocket from 'ws';
+import { Reply } from './xhr-utils';
+export declare function openSocket(url: string, sessionId: string): Promise<Reply<WebSocket>>;

package/build/tests/libs-for-tests/ws-utils.js

@@ -0,0 +1,59 @@
+"use strict";
+/*
+ Copyright (C) 2017, 2019 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSocket = void 0;
+const WebSocket = require("ws");
+const xhr_utils_1 = require("./xhr-utils");
+const processes_1 = require("../../lib-common/processes");
+const http_1 = require("../../lib-common/exceptions/http");
+const https_1 = require("https");
+function openSocket(url, sessionId) {
+    if (!url.startsWith('wss://')) {
+        throw new Error(`Url protocol must be wss`);
+    }
+    const headers = {};
+    headers[xhr_utils_1.SESSION_ID_HEADER] = sessionId;
+    const ws = new WebSocket(url, { headers, agent: https_1.globalAgent });
+    const opening = (0, processes_1.defer)();
+    const initOnError = err => opening.reject((0, http_1.makeConnectionException)(url, undefined, `Cannot open websocket connection due to error: ${err.message}`));
+    const onNonOkReply = (req, res) => {
+        const errReply = {
+            url,
+            method: 'GET',
+            status: res.statusCode,
+            data: undefined
+        };
+        opening.resolve(errReply);
+    };
+    ws.on('error', initOnError);
+    ws.on('unexpected-response', onNonOkReply);
+    ws.once('open', () => {
+        const okReply = {
+            url,
+            method: 'GET',
+            status: 200,
+            data: ws
+        };
+        opening.resolve(okReply);
+        ws.removeListener('error', initOnError);
+        ws.removeListener('unexpected-response', onNonOkReply);
+    });
+    return opening.promise;
+}
+exports.openSocket = openSocket;
+Object.freeze(exports);

package/build/tests/libs-for-tests/xhr-utils.d.ts

@@ -0,0 +1,61 @@
+import { HTTPException } from '../../lib-common/exceptions/http';
+export declare const SESSION_ID_HEADER = "X-Session-Id";
+export interface Reply<T> {
+    url: string;
+    method: string;
+    status: number;
+    data: T;
+    headers?: Headers;
+}
+export interface RequestOpts {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    url?: string;
+    path?: string;
+    responseType?: 'json' | 'arraybuffer';
+    sessionId?: string;
+    responseHeaders?: string[];
+}
+export interface Headers {
+    get(name: string): string | undefined;
+}
+export declare function request<T>(contentType: string | undefined, opts: RequestOpts): {
+    xhr: XMLHttpRequest;
+    promise: Promise<Reply<T>>;
+};
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: application/json' and
+ * sends given json.
+ * @param opts
+ * @param json
+ * @return a promise, resolvable to reply object
+ */
+export declare function doJsonRequest<T>(opts: RequestOpts, json: any): Promise<Reply<T>>;
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: application/octet-stream'
+ * and sends given bytes.
+ * @param opts
+ * @param bytes
+ * @return a promise, resolvable to reply object
+ */
+export declare function doBinaryRequest<T>(opts: RequestOpts, bytes: Uint8Array | Uint8Array[]): Promise<Reply<T>>;
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: text/plain'
+ * and sends given text
+ * @param opts
+ * @param txt
+ * @return a promise, resolvable to reply object
+ */
+export declare function doTextRequest<T>(opts: RequestOpts, txt: string): Promise<Reply<T>>;
+/**
+ * This assembles XMLHttpRequest without 'Content-Type'.
+ * @param opts
+ * @return a promise, resolvable to reply object
+ */
+export declare function doBodylessRequest<T>(opts: RequestOpts): Promise<Reply<T>>;
+/**
+ * @param rep
+ * @param errMsg
+ * @return http exception based on given reply, with an optional message
+ */
+export declare function makeException(rep: Reply<any>, errMsg?: string): HTTPException;
+export declare function extractIntHeader(rep: Reply<any>, headerName: string): number;

package/build/tests/libs-for-tests/xhr-utils.js

@@ -0,0 +1,154 @@
+"use strict";
+/*
+ Copyright (C) 2015 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractIntHeader = exports.makeException = exports.doBodylessRequest = exports.doTextRequest = exports.doBinaryRequest = exports.doJsonRequest = exports.request = exports.SESSION_ID_HEADER = void 0;
+const http_1 = require("../../lib-common/exceptions/http");
+const common_1 = require("../../lib-common/byte-streaming/common");
+const xhr2 = require('xhr2');
+exports.SESSION_ID_HEADER = "X-Session-Id";
+function makeHeadersInstanceFrom(xhr, selectHeaders) {
+    const m = new Map();
+    for (const h of selectHeaders) {
+        if (typeof h !== 'string') {
+            continue;
+        }
+        const value = xhr.getResponseHeader(h);
+        if (typeof value !== 'string') {
+            continue;
+        }
+        m.set(h.toLowerCase(), value);
+    }
+    return {
+        get(name) {
+            return m.get(name.toLowerCase());
+        }
+    };
+}
+function request(contentType, opts) {
+    const xhr = new xhr2();
+    const promise = new Promise((resolve, reject) => {
+        xhr.open(opts.method, opts.url);
+        xhr.onload = () => {
+            let data = xhr.response;
+            if ((opts.responseType === 'arraybuffer') &&
+                (data instanceof ArrayBuffer)) {
+                data = new Uint8Array(data);
+            }
+            const rep = {
+                url: opts.url,
+                method: opts.method,
+                status: xhr.status,
+                data: data
+            };
+            if (Array.isArray(opts.responseHeaders)) {
+                rep.headers = makeHeadersInstanceFrom(xhr, opts.responseHeaders);
+            }
+            resolve(rep);
+        };
+        xhr.onerror = ev => reject((0, http_1.makeConnectionException)(opts.url, opts.method, 'Cannot connect', ev));
+        if (contentType) {
+            xhr.setRequestHeader('Content-Type', contentType);
+        }
+        if (opts.sessionId) {
+            xhr.setRequestHeader(exports.SESSION_ID_HEADER, opts.sessionId);
+        }
+        if (opts.responseType) {
+            xhr.responseType = opts.responseType;
+        }
+    });
+    return { xhr, promise };
+}
+exports.request = request;
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: application/json' and
+ * sends given json.
+ * @param opts
+ * @param json
+ * @return a promise, resolvable to reply object
+ */
+function doJsonRequest(opts, json) {
+    const req = request('application/json', opts);
+    const body = ((json === undefined) ? '' : JSON.stringify(json));
+    req.xhr.send(body);
+    return req.promise;
+}
+exports.doJsonRequest = doJsonRequest;
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: application/octet-stream'
+ * and sends given bytes.
+ * @param opts
+ * @param bytes
+ * @return a promise, resolvable to reply object
+ */
+function doBinaryRequest(opts, bytes) {
+    const req = request('application/octet-stream', opts);
+    if (Array.isArray(bytes)) {
+        const fifo = new common_1.BytesFIFOBuffer();
+        for (const arr of bytes) {
+            fifo.push(arr);
+        }
+        req.xhr.send(fifo.getBytes(undefined));
+    }
+    else {
+        req.xhr.send(bytes);
+    }
+    return req.promise;
+}
+exports.doBinaryRequest = doBinaryRequest;
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: text/plain'
+ * and sends given text
+ * @param opts
+ * @param txt
+ * @return a promise, resolvable to reply object
+ */
+function doTextRequest(opts, txt) {
+    const req = request('text/plain', opts);
+    req.xhr.send(txt);
+    return req.promise;
+}
+exports.doTextRequest = doTextRequest;
+/**
+ * This assembles XMLHttpRequest without 'Content-Type'.
+ * @param opts
+ * @return a promise, resolvable to reply object
+ */
+function doBodylessRequest(opts) {
+    const req = request(undefined, opts);
+    req.xhr.send();
+    return req.promise;
+}
+exports.doBodylessRequest = doBodylessRequest;
+/**
+ * @param rep
+ * @param errMsg
+ * @return http exception based on given reply, with an optional message
+ */
+function makeException(rep, errMsg) {
+    return (0, http_1.makeHTTPException)(rep.url, rep.method, rep.status, errMsg);
+}
+exports.makeException = makeException;
+function extractIntHeader(rep, headerName) {
+    const intHeader = parseInt(rep.headers.get(headerName));
+    if (isNaN(intHeader)) {
+        throw makeException(rep, `Malformed response: header ${headerName} is missing or malformed`);
+    }
+    return intHeader;
+}
+exports.extractIntHeader = extractIntHeader;
+Object.freeze(exports);

package/build/tests/protocols/3nstorage/owner/specs/archive-obj-ver.d.ts

@@ -0,0 +1,2 @@
+import { SpecDescribe } from '../test-utils';
+export declare const specs: SpecDescribe;