core-3nweb-client-lib 0.44.12 → 0.45.0

package/build/tests/libs-for-tests/json-equal.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ Copyright (C) 2015, 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.deepEqual = deepEqual;
+function deepEqual(a, b, trimUndefinedObjFields = true) {
+    let t = typeof a;
+    if (t !== typeof b) {
+        return false;
+    }
+    if (t !== 'object') {
+        return (a === b);
+    }
+    if (a === b) {
+        return true;
+    }
+    if ((a === null) || (b === null)) {
+        return false;
+    }
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b)) {
+            return false;
+        }
+        let aArr = a;
+        let bArr = b;
+        if (aArr.length !== bArr.length) {
+            return false;
+        }
+        for (let i = 0; i < aArr.length; i += 1) {
+            if (!deepEqual(aArr[i], bArr[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        let aKeys = Object.keys(a);
+        let bKeys = Object.keys(b);
+        if (trimUndefinedObjFields) {
+            for (let i = 0; i < aKeys.length; i += 1) {
+                if (a[aKeys[i]] === undefined) {
+                    aKeys.splice(i, 1);
+                    i -= 1;
+                }
+            }
+            for (let i = 0; i < bKeys.length; i += 1) {
+                if (b[bKeys[i]] === undefined) {
+                    bKeys.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        for (let i = 0; i < aKeys.length; i += 1) {
+            let key = aKeys[i];
+            if (!deepEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+Object.freeze(exports);

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

@@ -0,0 +1,18 @@
+export declare class ServicesRunner {
+    readonly port: number;
+    readonly domains: {
+        noTokenSignup: string[];
+        other: string[];
+    };
+    private stopFn;
+    readonly dataFolder: string;
+    private serverNum;
+    constructor(port: number, domains: {
+        noTokenSignup: string[];
+        other: string[];
+    });
+    start(): Promise<void>;
+    stop(cleanup?: boolean): Promise<void>;
+    private cleanup;
+    createSingleUserSignupCtx(userId: string): Promise<string>;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ Copyright (C) 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.ServicesRunner = void 0;
+const path_1 = require("path");
+const async_fs_node_1 = require("../../lib-common/async-fs-node");
+const serverMod = require("spec-3nweb-server");
+const DATA_FOLDER = (0, path_1.join)(__dirname, '../../../test-server-data');
+let numOfRunningServers = 0;
+class ServicesRunner {
+    constructor(port, domains) {
+        this.port = port;
+        this.domains = domains;
+        this.stopFn = undefined;
+        numOfRunningServers += 1;
+        this.serverNum = numOfRunningServers;
+        this.dataFolder = `${DATA_FOLDER}-${this.serverNum}-${Date.now()}`;
+        Object.seal(this);
+    }
+    async start() {
+        const { stop } = await serverMod.mock.startOnLocalhost(this.dataFolder, this.port, this.domains);
+        this.stopFn = stop;
+    }
+    async stop(cleanup = true) {
+        if (!this.stopFn) {
+            return;
+        }
+        await this.stopFn();
+        this.stopFn = undefined;
+        if (cleanup) {
+            await this.cleanup();
+        }
+    }
+    async cleanup() {
+        numOfRunningServers -= 1;
+        await (0, async_fs_node_1.rmDirWithContent)(this.dataFolder).catch((exc) => {
+            if (!exc.notFound) {
+                throw exc;
+            }
+        });
+    }
+    createSingleUserSignupCtx(userId) {
+        return serverMod.addSingleUserSignup(this.dataFolder, userId);
+    }
+}
+exports.ServicesRunner = ServicesRunner;
+Object.freeze(ServicesRunner.prototype);
+Object.freeze(ServicesRunner);
+Object.freeze(exports);

package/build/tests/libs-for-tests/setups.d.ts

@@ -0,0 +1,51 @@
+import { CoreRunner, User } from "./core-runner";
+export interface Setup {
+    runner: CoreRunner;
+    signupDomains: string[];
+    isUp: boolean;
+    server: {
+        createSingleUserSignupCtx(userId: string): Promise<string>;
+    };
+}
+/**
+ * This creates a minimal working setup of core and server, and calls simple
+ * before and after methods, that do start and stop of everything.
+ * @param signupDomains are domains, for which server will create users without
+ * token and other.
+ * @return a setup object, for access to core, for restarting mid-test, etc.
+ */
+export declare function minimalSetup(signupDomains?: {
+    noTokenSignup: string[];
+    other: string[];
+}): Setup;
+type CommonW3N = web3n.caps.common.W3N;
+export interface MultiUserSetup {
+    users: User[];
+    runners: Map<string, CoreRunner>;
+    testAppCapsByUserIndex(i: number, viaIPC?: boolean): CommonW3N;
+    testAppCapsByUser(u: User, viaIPC?: boolean): CommonW3N;
+    sndDevByUserIndex(userNum: number, viaIPC?: boolean): Promise<DevForSetup>;
+    sndDevByUser(u: User, viaIPC?: boolean): Promise<DevForSetup>;
+    isUp: boolean;
+}
+/**
+ * This function creates users inside of usual
+ * @param users is a list of user ids to create. Default users are created,
+ * if no value given.
+ * Setup automatically sets DNS for domains from these ids.
+ * @return a setup object, for access to cores, for restarting mid-test, etc.
+ */
+export declare function setupWithUsers(setupTestAppCaps?: boolean, users?: string[]): MultiUserSetup;
+export declare function serviceWithMailerIdLogin(): {
+    serviceUrl: string;
+    isSessionValid: (sessionId: string) => Promise<boolean>;
+};
+export declare class DevForSetup {
+    private readonly runner;
+    private readonly viaIPC;
+    constructor(runner: CoreRunner, viaIPC?: boolean);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    get w3n(): web3n.caps.common.W3N;
+}
+export {};

package/build/tests/libs-for-tests/setups.js

@@ -0,0 +1,305 @@
+"use strict";
+/*
+ Copyright (C) 2020 - 2022, 2026 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.DevForSetup = void 0;
+exports.minimalSetup = minimalSetup;
+exports.setupWithUsers = setupWithUsers;
+exports.serviceWithMailerIdLogin = serviceWithMailerIdLogin;
+const core_runner_1 = require("./core-runner");
+const jasmine_utils_1 = require("./jasmine-utils");
+const timeout_1 = require("../../lib-common/processes/timeout");
+const services_runner_1 = require("./services-runner");
+const assert_1 = require("../../lib-common/assert");
+const request_utils_1 = require("../../lib-client/request-utils");
+const retrieval_1 = require("../../lib-common/service-api/asmail/retrieval");
+const sleep_1 = require("../../lib-common/processes/sleep");
+const SERVICE_PORT = 8088;
+const SIGNUP_URL = `https://localhost:${SERVICE_PORT}/signup/`;
+function makeSetupObject(domains) {
+    const runner = new core_runner_1.CoreRunner(SIGNUP_URL);
+    const server = new services_runner_1.ServicesRunner(SERVICE_PORT, domains);
+    let isUp = false;
+    let isStopped = false;
+    const s = {
+        get runner() { return runner; },
+        get signupDomains() { return domains.noTokenSignup; },
+        get isUp() { return isUp; },
+        get server() {
+            return {
+                createSingleUserSignupCtx: (userId) => server.createSingleUserSignupCtx(userId)
+            };
+        }
+    };
+    async function setUp() {
+        try {
+            await server.start();
+            isUp = true;
+        }
+        catch (err) {
+            await setDown().catch(() => { });
+            throw err;
+        }
+    }
+    async function setDown() {
+        if (isStopped) {
+            return;
+        }
+        isUp = false;
+        isStopped = true;
+        await (0, sleep_1.sleep)(1000);
+        try {
+            try {
+                await runner.close()
+                    .catch(err => {
+                    console.error(`\n>>> error in closing core's runner`, err);
+                    throw err;
+                });
+            }
+            finally {
+                await runner.cleanup(true)
+                    .catch(err => {
+                    console.error(`\n>>> error in cleanup of core's runner`, err);
+                    throw err;
+                });
+            }
+        }
+        finally {
+            await server.stop()
+                .catch(err => {
+                console.error(`\n>>> error in stopping server`, err);
+                throw err;
+            });
+        }
+    }
+    return { s, setUp, setDown };
+}
+/**
+ * This creates a minimal working setup of core and server, and calls simple
+ * before and after methods, that do start and stop of everything.
+ * @param signupDomains are domains, for which server will create users without
+ * token and other.
+ * @return a setup object, for access to core, for restarting mid-test, etc.
+ */
+function minimalSetup(signupDomains = {
+    noTokenSignup: ['company.inc', 'personal.net'],
+    other: []
+}) {
+    const { s, setDown, setUp } = makeSetupObject(signupDomains);
+    (0, jasmine_utils_1.beforeAllWithTimeoutLog)(() => setUp());
+    (0, jasmine_utils_1.afterAllCond)(async () => {
+        if (s.isUp) {
+            await (0, timeout_1.callWithTimeout)(setDown, 5000, () => `Timeout when calling teardown of test setup`).catch(async (err) => {
+                console.log(`\n>>> error in teardown:`, err);
+            });
+        }
+    }, 6000);
+    return s;
+}
+function makeMultiUserSetupObject(domains) {
+    const runners = new Map();
+    const sndDevRunners = new Map();
+    const server = new services_runner_1.ServicesRunner(SERVICE_PORT, domains);
+    const users = [];
+    let isUp = false;
+    let isStopped = false;
+    function testAppCapsByUser(u, viaIPC = true) {
+        const r = runners.get(u.userId);
+        (0, assert_1.assert)(!!r, `Core runner is missing for user ${u.userId}`);
+        if (viaIPC) {
+            return r.appCapsViaIPC;
+        }
+        else {
+            return r.rawAppCaps;
+        }
+    }
+    function testAppCapsByUserIndex(i, viaIPC) {
+        const u = users[i];
+        (0, assert_1.assert)(!!u, `Given index ${i} is not pointing to existing user`);
+        return testAppCapsByUser(u, viaIPC);
+    }
+    async function sndDevByUser(u, viaIPC = true) {
+        let r = sndDevRunners.get(u.userId);
+        if (!r) {
+            const mainR = runners.get(u.userId);
+            (0, assert_1.assert)(!!mainR, `Core runner is missing for user ${u.userId}`);
+            r = await mainR.makeAndLoginNewCore();
+            sndDevRunners.set(u.userId, r);
+        }
+        return new DevForSetup(r, viaIPC);
+    }
+    function sndDevByUserIndex(i, viaIPC = true) {
+        const u = users[i];
+        (0, assert_1.assert)(!!u, `Given index ${i} is not pointing to existing user`);
+        return sndDevByUser(u, viaIPC);
+    }
+    const s = {
+        runners,
+        users,
+        get isUp() { return isUp; },
+        testAppCapsByUser,
+        testAppCapsByUserIndex,
+        sndDevByUser,
+        sndDevByUserIndex
+    };
+    async function createUser(userId) {
+        const runner = new core_runner_1.CoreRunner(SIGNUP_URL);
+        const user = await runner.createUser(userId)
+            .catch(async (err) => {
+            await runner.cleanup(true);
+            throw err;
+        });
+        runners.set(user.userId, runner);
+        users.push(user);
+        return user;
+    }
+    async function setUp(users) {
+        try {
+            await server.start();
+            const makingUsers = users.map(address => createUser(address));
+            await Promise.all(makingUsers);
+            isUp = true;
+        }
+        catch (err) {
+            await setDown().catch(() => { });
+            throw err;
+        }
+    }
+    async function setDown() {
+        if (isStopped) {
+            return;
+        }
+        isUp = false;
+        isStopped = true;
+        await (0, sleep_1.sleep)(1000);
+        try {
+            for (const iter of [runners.values(), sndDevRunners.values()]) {
+                for (const runner of iter) {
+                    try {
+                        await runner.close()
+                            .catch(err => {
+                            console.error(`\n>>> error in closing core's runner`, err);
+                            throw err;
+                        });
+                    }
+                    finally {
+                        await runner.cleanup(true)
+                            .catch(err => {
+                            console.error(`\n>>> error in cleanup of core's runner`, err);
+                            throw err;
+                        });
+                    }
+                }
+            }
+        }
+        finally {
+            await server.stop()
+                .catch(err => {
+                console.error(`\n>>> error in stopping server`, err);
+                throw err;
+            });
+        }
+    }
+    return { s, setUp, setDown };
+}
+/**
+ * This function creates users inside of usual
+ * @param users is a list of user ids to create. Default users are created,
+ * if no value given.
+ * Setup automatically sets DNS for domains from these ids.
+ * @return a setup object, for access to cores, for restarting mid-test, etc.
+ */
+function setupWithUsers(setupTestAppCaps = true, users = ['Bob Marley @rock.cafe']) {
+    if (users.length === 0) {
+        throw new Error('No user given to setup.');
+    }
+    const { s, setDown, setUp } = makeMultiUserSetupObject({
+        noTokenSignup: users.map(domainFromUserId),
+        other: []
+    });
+    (0, jasmine_utils_1.beforeAllWithTimeoutLog)(async () => {
+        await setUp(users);
+        if (setupTestAppCaps) {
+            for (const runner of s.runners.values()) {
+                runner.setupTestAppCaps();
+            }
+        }
+    }, users.length * 7000);
+    (0, jasmine_utils_1.afterAllCond)(async () => {
+        if (s.isUp) {
+            await (0, timeout_1.callWithTimeout)(setDown, 5000, () => `Timeout when calling teardown of test setup`).catch(async (err) => {
+                console.log(`\n>>> error in teardown:`, err);
+            });
+        }
+    }, 6000);
+    return s;
+}
+function domainFromUserId(userId) {
+    const indAt = userId.indexOf('@');
+    if (indAt < 0) {
+        return userId;
+    }
+    else {
+        return userId.substring(indAt + 1);
+    }
+}
+function serviceWithMailerIdLogin() {
+    const testSrv = (new URL(SIGNUP_URL)).host;
+    const serviceUrl = `https://${testSrv}/asmail/retrieval/login/mailerid`;
+    const net = (0, request_utils_1.makeNetClient)();
+    async function isSessionValid(sessionId) {
+        const rep = await net.doBodylessRequest({
+            url: `https://${testSrv}/asmail/retrieval/${retrieval_1.listMsgs.genUrlEnd()}`,
+            method: 'GET',
+            responseType: 'json',
+            sessionId
+        });
+        if (rep.status === retrieval_1.listMsgs.SC.ok) {
+            return true;
+        }
+        else if (rep.status === 403) {
+            return false;
+        }
+        else {
+            throw Error(`Got ${rep.status} from service`);
+        }
+    }
+    return { serviceUrl, isSessionValid };
+}
+class DevForSetup {
+    constructor(runner, viaIPC = true) {
+        this.runner = runner;
+        this.viaIPC = viaIPC;
+        Object.seal(this);
+    }
+    async start() {
+        await this.runner.loginUser();
+        this.runner.setupTestAppCaps();
+    }
+    async stop() {
+        await this.runner.close();
+    }
+    get w3n() {
+        return (this.viaIPC ?
+            this.runner.appCapsViaIPC :
+            this.runner.rawAppCaps);
+    }
+}
+exports.DevForSetup = DevForSetup;
+Object.freeze(DevForSetup.prototype);
+Object.freeze(DevForSetup);
+Object.freeze(exports);

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

@@ -0,0 +1,16 @@
+export interface SpecIt<S> {
+    expectation: string;
+    disableIn?: DisableFlag | DisableFlag[];
+    notIncludedIn?: DisableFlag | DisableFlag[];
+    func?: (setup: S) => Promise<void>;
+    timeout?: number;
+}
+export type DisableFlag = 'device-fs' | 'win-local-fs';
+export interface SpecDescribe {
+    description: string;
+    its: SpecIt<any>[];
+    focused?: boolean;
+}
+export declare function loadSpecs<S extends {
+    isUp: boolean;
+}>(setup: S | undefined, folderWithModules: string, offFlags?: DisableFlag[]): void;

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

@@ -0,0 +1,92 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2018, 2020, 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.loadSpecs = loadSpecs;
+const jasmine_utils_1 = require("./jasmine-utils");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function readSpecs(folderWithModules) {
+    const specs = [];
+    const modulesWithSpecs = (0, fs_1.readdirSync)(folderWithModules)
+        .filter(fName => fName.endsWith('.js'));
+    for (const fName of modulesWithSpecs) {
+        const s = require((0, path_1.join)(folderWithModules, fName)).specs;
+        if (s) {
+            specs.push(s);
+        }
+        else {
+            console.error(`Module ${fName} is not exposing specs objects with tests`);
+        }
+    }
+    return specs;
+}
+function specFuncFor(it, offFlags) {
+    if (offFlags) {
+        if (it.notIncludedIn) {
+            if (Array.isArray(it.notIncludedIn)) {
+                for (const flag of it.notIncludedIn) {
+                    if (offFlags.includes(flag)) {
+                        return;
+                    }
+                }
+            }
+            else {
+                if (offFlags.includes(it.notIncludedIn)) {
+                    return;
+                }
+            }
+        }
+        if (it.disableIn) {
+            if (Array.isArray(it.disableIn)) {
+                for (const flag of it.disableIn) {
+                    if (offFlags.includes(flag)) {
+                        return jasmine_utils_1.xitCond;
+                    }
+                }
+            }
+            else {
+                if (offFlags.includes(it.disableIn)) {
+                    return jasmine_utils_1.xitCond;
+                }
+            }
+        }
+    }
+    return jasmine_utils_1.itCond;
+}
+function loadSpecs(setup, folderWithModules, offFlags) {
+    const specs = readSpecs(folderWithModules);
+    specs.forEach((d) => {
+        const describeFn = (d.focused ? fdescribe : describe);
+        const its = d.its
+            .map(it => ({ spec: specFuncFor(it, offFlags), it }))
+            .filter(({ spec }) => !!spec);
+        if (its.length > 0) {
+            describeFn(d.description, () => {
+                its.forEach(({ spec, it }) => {
+                    spec(it.expectation, async function () {
+                        if (!it.func || (setup && !setup.isUp)) {
+                            return;
+                        }
+                        await it.func(setup);
+                    }, it.timeout);
+                });
+            });
+        }
+    });
+}
+Object.freeze(exports);

package/build/tests/libs-for-tests/startup.d.ts

@@ -0,0 +1 @@
+export declare function checkKeyDerivNotifications(notifPerc: number[]): void;

package/build/tests/libs-for-tests/startup.js

@@ -0,0 +1,29 @@
+"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.checkKeyDerivNotifications = checkKeyDerivNotifications;
+function checkKeyDerivNotifications(notifPerc) {
+    expect(notifPerc.length).toBeGreaterThan(0);
+    let prevP = -1;
+    for (let i = 0; i < notifPerc.length; i += 1) {
+        const p = notifPerc[i];
+        expect(p).toBeGreaterThan(prevP);
+        prevP = p;
+    }
+}
+Object.freeze(exports);

package/build/tests/libs-for-tests/watching.d.ts

@@ -0,0 +1,7 @@
+import { Subscriber } from 'rxjs';
+export type WatchSetup<T> = (obs: Subscriber<T>) => (() => void);
+export type FilterPredicate<T> = (ev: T) => boolean;
+export declare function watchForEvents<T>(setupFn: WatchSetup<T>, numOfEvents: number, predicate?: FilterPredicate<T>, timeoutMillis?: number): {
+    collectedEvents: T[];
+    completion: Promise<void>;
+};