spec-3nweb-server 1.8.5 → 1.8.7

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

@@ -0,0 +1,114 @@
+"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.doMailerIdLogin = exports.provisionMidSigner = exports.startMidSession = exports.getMidRoot = exports.getProvPath = void 0;
+const jwkeys_1 = require("../../lib-common/jwkeys");
+const xhr_utils_1 = require("./xhr-utils");
+const login_1 = require("../../lib-common/service-api/mailer-id/login");
+const provisioning_1 = require("../../lib-common/service-api/mailer-id/provisioning");
+const mid_sigs_NaCl_Ed_1 = require("../../lib-common/mid-sigs-NaCl-Ed");
+const pkl_1 = require("./pkl");
+const random_node_1 = require("../../lib-common/random-node");
+const url_1 = require("url");
+async function getMidData(midUrl) {
+    let reqOpts = {
+        url: midUrl,
+        method: 'GET',
+        responseType: 'json'
+    };
+    let rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+    expect(rep.status).toBe(200);
+    return rep.data;
+}
+/**
+ * @param midUrl
+ * @return a promise, resolvable to MailerId service's provisioning url.
+ */
+async function getProvPath(midUrl) {
+    let midData = await getMidData(midUrl);
+    let prov = midData['provisioning'];
+    expect(typeof prov).toBe('string');
+    // return url with provision path
+    let pathStarts = midUrl.indexOf('/', midUrl.indexOf('://') + 3);
+    return midUrl.substring(0, pathStarts) + prov;
+}
+exports.getProvPath = getProvPath;
+async function getMidRoot(midUrl) {
+    let midData = await getMidData(midUrl);
+    let rootCert = midData["current-cert"];
+    expect((0, jwkeys_1.isLikeSignedKeyCert)(rootCert)).toBe(true);
+    return rootCert;
+}
+exports.getMidRoot = getMidRoot;
+async function startMidSession(loginUrl, userId) {
+    let reqOpts = {
+        url: loginUrl + login_1.startSession.URL_END,
+        method: 'POST',
+        responseType: 'json'
+    };
+    let req = { userId };
+    let rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+    expect(rep.status).toBe(login_1.startSession.SC.ok);
+    return rep.data.sessionId;
+}
+exports.startMidSession = startMidSession;
+async function provisionMidSigner(midServiceUrl, user) {
+    let provUrl = await getProvPath(midServiceUrl);
+    let sessParams = await (0, pkl_1.doPubKeyLogin)(provUrl, user);
+    let reqOpts = {
+        url: provUrl + provisioning_1.certify.URL_END,
+        method: 'POST',
+        sessionId: sessParams.sessionId,
+        responseType: 'arraybuffer'
+    };
+    let midSigningPair = mid_sigs_NaCl_Ed_1.user.generateSigningKeyPair(random_node_1.bytesSync);
+    let reqData = {
+        pkey: midSigningPair.pkey,
+        duration: 12 * 60 * 60
+    };
+    let encrBody = sessParams.sessEncr.packJSON(reqData);
+    let rep = await (0, xhr_utils_1.doBinaryRequest)(reqOpts, encrBody);
+    expect(rep.status).toBe(provisioning_1.certify.SC.ok);
+    let repData = sessParams.sessEncr.openJSON(rep.data);
+    return mid_sigs_NaCl_Ed_1.user.makeMailerIdSigner(midSigningPair.skey, repData.userCert, repData.provCert);
+}
+exports.provisionMidSigner = provisionMidSigner;
+async function doMailerIdLogin(loginUrl, user) {
+    let sessionId = await startMidSession(loginUrl, user.id);
+    let midSigner = await provisionMidSigner(user.midUrl, user);
+    let reqOpts = {
+        url: loginUrl + login_1.authSession.URL_END,
+        method: 'POST',
+        responseType: 'json',
+        sessionId
+    };
+    let serviceDomain = (0, url_1.parse)(loginUrl).hostname;
+    if (!serviceDomain) {
+        throw new Error(`Cannot parse hostname from login url ${loginUrl}`);
+    }
+    let req = {
+        assertion: midSigner.generateAssertionFor(serviceDomain, sessionId),
+        provCert: midSigner.providerCert,
+        userCert: midSigner.userCert
+    };
+    let rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+    expect(rep.status).toBe(login_1.authSession.SC.ok);
+    return sessionId;
+}
+exports.doMailerIdLogin = doMailerIdLogin;
+Object.freeze(exports);

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

@@ -0,0 +1,28 @@
+import * as pklApi from '../../lib-common/service-api/pub-key-login';
+import { SessionEncryptor } from '../../lib-common/session-encryptor';
+export interface User {
+    id: string;
+    loginDefaultSKey: Uint8Array;
+    loginLabeledSKey: {
+        kid: string;
+        k: Uint8Array;
+    };
+    midUrl: string;
+    storageOwnerUrl: string;
+}
+export interface ExchangeCrypto {
+    sessEncr: SessionEncryptor;
+    serverVerificationBytes: Uint8Array;
+    encResponse: Uint8Array;
+}
+export declare function decryptSessionParamsForCurve25519(r: pklApi.start.Reply, loginSKey: Uint8Array): ExchangeCrypto;
+export interface ExchangeParams {
+    crypto: ExchangeCrypto;
+    sessionId: string;
+}
+export declare function startPKLSession(loginUrl: string, user: User, useDefaultKey: boolean): Promise<ExchangeParams>;
+export interface SessionParams {
+    sessEncr: SessionEncryptor;
+    sessionId: string;
+}
+export declare function doPubKeyLogin(loginUrl: string, user: User): Promise<SessionParams>;

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

@@ -0,0 +1,89 @@
+"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.doPubKeyLogin = exports.startPKLSession = exports.decryptSessionParamsForCurve25519 = void 0;
+const pklApi = require("../../lib-common/service-api/pub-key-login");
+const buffer_utils_1 = require("../../lib-common/buffer-utils");
+const ecma_nacl_1 = require("ecma-nacl");
+const session_encryptor_1 = require("../../lib-common/session-encryptor");
+const xhr_utils_1 = require("./xhr-utils");
+const url_1 = require("url");
+const bytes_equal_1 = require("./bytes-equal");
+function decryptSessionParamsForCurve25519(r, loginSKey) {
+    let serverPKey = buffer_utils_1.base64.open(r.serverPubKey);
+    expect(serverPKey.length).toBe(ecma_nacl_1.box.KEY_LENGTH);
+    let sharedKey = ecma_nacl_1.box.calc_dhshared_key(serverPKey, loginSKey);
+    let encChallenge = buffer_utils_1.base64.open(r.sessionKey);
+    expect(encChallenge.length).toBe(ecma_nacl_1.secret_box.NONCE_LENGTH + ecma_nacl_1.secret_box.KEY_LENGTH);
+    let nonce = encChallenge.subarray(0, ecma_nacl_1.secret_box.NONCE_LENGTH);
+    let zeros = new Uint8Array(ecma_nacl_1.secret_box.KEY_LENGTH);
+    let stream = ecma_nacl_1.secret_box.pack(zeros, nonce, sharedKey).subarray(ecma_nacl_1.secret_box.POLY_LENGTH);
+    let sessionKey = new Uint8Array(encChallenge.subarray(ecma_nacl_1.secret_box.NONCE_LENGTH));
+    for (var i = 0; i < ecma_nacl_1.secret_box.KEY_LENGTH; i += 1) {
+        sessionKey[i] ^= stream[i];
+    }
+    let serverVerificationBytes = ecma_nacl_1.secret_box.pack(sessionKey, nonce, sharedKey)
+        .subarray(0, ecma_nacl_1.secret_box.POLY_LENGTH);
+    ecma_nacl_1.nonce.advanceOddly(nonce);
+    let sessEncr = (0, session_encryptor_1.makeSessionEncryptor)(sessionKey, nonce);
+    let encResponse = sessEncr.pack(sessionKey);
+    ecma_nacl_1.arrays.wipe(sessionKey);
+    return { sessEncr, serverVerificationBytes, encResponse };
+}
+exports.decryptSessionParamsForCurve25519 = decryptSessionParamsForCurve25519;
+async function startPKLSession(loginUrl, user, useDefaultKey) {
+    let reqOpts = {
+        url: (0, url_1.resolve)(loginUrl, pklApi.start.URL_END),
+        method: 'POST',
+        responseType: 'json'
+    };
+    let req = (useDefaultKey ?
+        { userId: user.id } :
+        { userId: user.id, kid: user.loginLabeledSKey.kid });
+    let rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+    expect(rep.status).toBe(pklApi.start.SC.ok);
+    let skey = (useDefaultKey ? user.loginDefaultSKey : user.loginLabeledSKey.k);
+    return {
+        sessionId: rep.data.sessionId,
+        crypto: decryptSessionParamsForCurve25519(rep.data, skey)
+    };
+}
+exports.startPKLSession = startPKLSession;
+async function validatePKLSession(loginUrl, exchangeParams) {
+    let reqOpts = {
+        url: (0, url_1.resolve)(loginUrl, pklApi.complete.URL_END),
+        method: 'POST',
+        sessionId: exchangeParams.sessionId,
+        responseType: 'arraybuffer'
+    };
+    let rep = await (0, xhr_utils_1.doBinaryRequest)(reqOpts, exchangeParams.crypto.encResponse);
+    expect(rep.status).toBe(pklApi.complete.SC.ok);
+    expect(rep.data.length).toBe(ecma_nacl_1.secret_box.POLY_LENGTH);
+    expect((0, bytes_equal_1.bytesEqual)(rep.data, exchangeParams.crypto.serverVerificationBytes))
+        .toBe(true);
+    return {
+        sessionId: exchangeParams.sessionId,
+        sessEncr: exchangeParams.crypto.sessEncr
+    };
+}
+async function doPubKeyLogin(loginUrl, user) {
+    let exchangeParams = await startPKLSession(loginUrl, user, false);
+    return validatePKLSession(loginUrl, exchangeParams);
+}
+exports.doPubKeyLogin = doPubKeyLogin;
+Object.freeze(exports);

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

@@ -0,0 +1,20 @@
+import { Component } from './component';
+import { User } from '../pkl';
+import { Obj } from '../3nstorage';
+export declare class StorageComponent extends Component {
+    midServiceDomain: string;
+    constructor(signupDomains: string[], midServiceDomain: string);
+    addUser(userId: string, configureDNS?: boolean): Promise<User>;
+    get midUrl(): string;
+    get storageUrl(): string;
+    getStorageOwnerUrl(): Promise<string>;
+    private storeFolder;
+    private checkTransactionPresence;
+    rootTransactionExists(userId: string, transactionId?: string): Promise<boolean>;
+    transactionExists(userId: string, objId: string, transactionId?: string): Promise<boolean>;
+    private checkCurrentObjPresence;
+    currentRootObjExists(userId: string, ver?: number, obj?: Obj): Promise<boolean>;
+    currentObjExists(userId: string, objId: string, ver?: number, obj?: Obj): Promise<boolean>;
+    clearStorage(userId: string): Promise<void>;
+    restartAndClearStorageFor(userId: string): Promise<void>;
+}

package/build/tests/libs-for-tests/server-components/3nstorage.js

@@ -0,0 +1,200 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2019 - 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.StorageComponent = void 0;
+const component_1 = require("./component");
+const mailerid_1 = require("./mailerid");
+const url_1 = require("url");
+const _3nstorage_1 = require("../3nstorage");
+const fs = require("../../../lib-common/async-fs-node");
+const bytes_equal_1 = require("../bytes-equal");
+const obj_file_1 = require("../../../lib-common/objs-on-disk/obj-file");
+const path_1 = require("path");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const server_data_folders_1 = require("../../../lib-server/resources/server-data-folders");
+async function rmFolderContent(folder) {
+    await fs.rmDirWithContent(folder);
+    await fs.mkdir(folder);
+}
+class StorageComponent extends component_1.Component {
+    constructor(signupDomains, midServiceDomain) {
+        super({
+            rootFolder: null,
+            domain: midServiceDomain,
+            signup: {},
+            enabledServices: {
+                mailerId: true,
+                storage: true
+            },
+            mailerId: {
+                certs: null
+            }
+        }, signupDomains);
+        this.midServiceDomain = midServiceDomain;
+        Object.seal(this);
+    }
+    async addUser(userId, configureDNS = true) {
+        if (configureDNS) {
+            this.dns.configureFor(userId);
+        }
+        let user = await (0, mailerid_1.addUserIn)(this.url, userId);
+        user.midUrl = this.midUrl;
+        user.storageOwnerUrl = await this.getStorageOwnerUrl();
+        return user;
+    }
+    get midUrl() {
+        return (0, url_1.resolve)(this.url, 'mailerid/');
+    }
+    get storageUrl() {
+        return (0, url_1.resolve)(this.url, '3nstorage/');
+    }
+    async getStorageOwnerUrl() {
+        let storageOwnerUrl = await (0, _3nstorage_1.get3NStorageServiceUrl)(this.storageUrl, 'owner');
+        if (!storageOwnerUrl.endsWith('/')) {
+            storageOwnerUrl += '/';
+        }
+        return storageOwnerUrl;
+    }
+    storeFolder(userId) {
+        return (0, path_1.join)((0, server_data_folders_1.userDataInRootFolder)(this.conf.rootFolder, userId), 'store');
+    }
+    async checkTransactionPresence(transFolder, transactionId) {
+        const transFile = 'transaction';
+        try {
+            const lst = await fs.readdir(transFolder);
+            expect(lst).toContain(transFile);
+        }
+        catch (exc) {
+            if (exc.notFound) {
+                return false;
+            }
+            else {
+                throw exc;
+            }
+        }
+        if (transactionId) {
+            const trans = JSON.parse(await fs.readFile((0, path_1.join)(transFolder, transFile), { encoding: 'utf8' }));
+            return (trans.transactionId === transactionId);
+        }
+        return true;
+    }
+    rootTransactionExists(userId, transactionId) {
+        return this.checkTransactionPresence((0, path_1.join)(this.storeFolder(userId), 'root', 'transaction'), transactionId);
+    }
+    transactionExists(userId, objId, transactionId) {
+        return this.checkTransactionPresence((0, path_1.join)(this.storeFolder(userId), 'transactions', objId), transactionId);
+    }
+    async checkCurrentObjPresence(objFolder, ver, obj) {
+        let status;
+        try {
+            status = JSON.parse(await fs.readFile(objFolder + '/status', { encoding: 'utf8' }));
+        }
+        catch (exc) {
+            if (exc.notFound) {
+                return false;
+            }
+            else {
+                throw exc;
+            }
+        }
+        if (status.state !== 'current') {
+            return false;
+        }
+        const currVer = status.currentVersion;
+        if ((ver !== undefined) && (currVer !== ver)) {
+            return false;
+        }
+        if (obj) {
+            const filePath = (0, path_1.join)(objFolder, `${currVer}.v`);
+            const file = await obj_file_1.ObjVersionFile.forExisting(filePath)
+                .catch((exc) => {
+                if (exc.notFound) {
+                    return undefined;
+                }
+                throw exc;
+            });
+            if (!file) {
+                return false;
+            }
+            const headerInFile = await file.readHeader();
+            if (!headerInFile
+                || !(0, bytes_equal_1.bytesEqual)(headerInFile, obj.header)) {
+                return false;
+            }
+            const diff = obj.diff;
+            if (file.getBaseVersion() === undefined) {
+                if (diff) {
+                    return false;
+                }
+                const segsInFile = (0, buffer_utils_1.joinByteArrs)(await file.readSegs(0, file.getTotalSegsLen()));
+                if (!(0, bytes_equal_1.bytesEqual)(segsInFile, obj.segs)) {
+                    return false;
+                }
+            }
+            else {
+                if (!diff) {
+                    return false;
+                }
+                if (file.getBaseVersion() !== diff.baseVersion) {
+                    return false;
+                }
+                if (file.getTotalSegsLen() !== diff.segsSize) {
+                    return false;
+                }
+                let ofs = 0;
+                for (const [isNew, dsOfs, len] of diff.sections) {
+                    if (isNew === 0) {
+                        const sections = await file.segsLocations(ofs, len);
+                        for (const section of sections) {
+                            if (section.type !== 'base') {
+                                return false;
+                            }
+                        }
+                    }
+                    else {
+                        if (!(0, bytes_equal_1.bytesEqual)((0, buffer_utils_1.joinByteArrs)(await file.readSegs(ofs, len)), obj.segs.subarray(dsOfs, dsOfs + len))) {
+                            return false;
+                        }
+                    }
+                    ofs += len;
+                }
+            }
+        }
+        return true;
+    }
+    currentRootObjExists(userId, ver, obj) {
+        return this.checkCurrentObjPresence((0, path_1.join)(this.storeFolder(userId), 'root'), ver, obj);
+    }
+    currentObjExists(userId, objId, ver, obj) {
+        return this.checkCurrentObjPresence((0, path_1.join)(this.storeFolder(userId), 'objects', objId), ver, obj);
+    }
+    async clearStorage(userId) {
+        let storeFolder = this.storeFolder(userId);
+        await rmFolderContent((0, path_1.join)(storeFolder, 'transactions'));
+        await rmFolderContent((0, path_1.join)(storeFolder, 'objects'));
+        await rmFolderContent((0, path_1.join)(storeFolder, 'root'));
+    }
+    async restartAndClearStorageFor(userId) {
+        await this.clearStorage(userId);
+        await this.restart();
+    }
+}
+exports.StorageComponent = StorageComponent;
+Object.freeze(StorageComponent.prototype);
+Object.freeze(StorageComponent);
+Object.freeze(exports);

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

@@ -0,0 +1,6 @@
+import { Component } from './component';
+export declare class AdminComponent extends Component {
+    constructor(signupDomains: string[]);
+    get signupUrl(): string;
+    createSingleUserSignupTokenFor(userId: string): Promise<string>;
+}

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

@@ -0,0 +1,43 @@
+"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.AdminComponent = void 0;
+const component_1 = require("./component");
+const url_1 = require("url");
+const lib_1 = require("../../../lib");
+class AdminComponent extends component_1.Component {
+    constructor(signupDomains) {
+        super({
+            rootFolder: null,
+            domain: null,
+            signup: {},
+            enabledServices: {}
+        }, signupDomains);
+        Object.seal(this);
+    }
+    get signupUrl() {
+        return (0, url_1.resolve)(this.url, 'signup/');
+    }
+    createSingleUserSignupTokenFor(userId) {
+        return (0, lib_1.addSingleUserSignup)(this.dataFolder, userId);
+    }
+}
+exports.AdminComponent = AdminComponent;
+Object.freeze(AdminComponent.prototype);
+Object.freeze(AdminComponent);
+Object.freeze(exports);

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

@@ -0,0 +1,16 @@
+import { Component } from './component';
+import { User } from '../pkl';
+import { Msg } from '../asmail';
+export declare class ASMailComponent extends Component {
+    midServiceDomain: string;
+    constructor(signupDomains: string[], midServiceDomain: string);
+    addUser(userId: string, configureDNS?: boolean): Promise<User>;
+    get midUrl(): string;
+    get asmailUrl(): string;
+    getConfUrl(): Promise<string>;
+    getDeliveryUrl(): Promise<string>;
+    getRetrievalUrl(): Promise<string>;
+    private inboxFolder;
+    private msgFolder;
+    msgExists(userId: string, msgId: string, deliveryComplete: boolean, msg?: Msg): Promise<boolean>;
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2017, 2019 - 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.ASMailComponent = void 0;
+const component_1 = require("./component");
+const mailerid_1 = require("./mailerid");
+const url_1 = require("url");
+const asmail_1 = require("../asmail");
+const fs = require("../../../lib-common/async-fs-node");
+const bytes_equal_1 = require("../bytes-equal");
+const path_1 = require("path");
+const obj_file_1 = require("../../../lib-common/objs-on-disk/obj-file");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const server_data_folders_1 = require("../../../lib-server/resources/server-data-folders");
+class ASMailComponent extends component_1.Component {
+    constructor(signupDomains, midServiceDomain) {
+        super({
+            rootFolder: null,
+            domain: midServiceDomain,
+            signup: {},
+            enabledServices: {
+                mailerId: true,
+                asmail: true
+            },
+            mailerId: {
+                certs: null
+            }
+        }, signupDomains);
+        this.midServiceDomain = midServiceDomain;
+        Object.seal(this);
+    }
+    async addUser(userId, configureDNS = true) {
+        if (configureDNS) {
+            this.dns.configureFor(userId);
+        }
+        let user = await (0, mailerid_1.addUserIn)(this.url, userId);
+        user.midUrl = this.midUrl;
+        return user;
+    }
+    get midUrl() {
+        return (0, url_1.resolve)(this.url, 'mailerid/');
+    }
+    get asmailUrl() {
+        return (0, url_1.resolve)(this.url, 'asmail/');
+    }
+    getConfUrl() {
+        return (0, asmail_1.getASMailServiceUrl)(this.asmailUrl, 'config');
+    }
+    getDeliveryUrl() {
+        return (0, asmail_1.getASMailServiceUrl)(this.asmailUrl, 'delivery');
+    }
+    getRetrievalUrl() {
+        return (0, asmail_1.getASMailServiceUrl)(this.asmailUrl, 'retrieval');
+    }
+    inboxFolder(userId) {
+        return (0, path_1.join)((0, server_data_folders_1.userDataInRootFolder)(this.conf.rootFolder, userId), 'mail');
+    }
+    msgFolder(userId, msgId, deliveryComplete) {
+        return (0, path_1.join)(this.inboxFolder(userId), (deliveryComplete ? 'messages' : 'delivery'), msgId);
+    }
+    // XXX adopt new file access
+    async msgExists(userId, msgId, deliveryComplete, msg) {
+        let meta;
+        let msgFolder = this.msgFolder(userId, msgId, deliveryComplete);
+        try {
+            let metaFile = (0, path_1.join)(msgFolder, 'meta.json');
+            meta = JSON.parse(await fs.readFile(metaFile, { encoding: 'utf8' }));
+        }
+        catch (exc) {
+            if (exc.notFound) {
+                return false;
+            }
+            else {
+                throw exc;
+            }
+        }
+        let extMeta = meta.extMeta;
+        if (!deliveryComplete || !msg) {
+            return true;
+        }
+        // check meta
+        if (msg.cryptoMeta.pid) {
+            expect(extMeta.pid).withContext('correct key-pair id in meta').toBe(msg.cryptoMeta.pid);
+        }
+        if (msg.cryptoMeta.recipientKid) {
+            expect(extMeta.recipientKid).withContext('correct recipient key id in meta').toBe(msg.cryptoMeta.recipientKid);
+        }
+        if (msg.cryptoMeta.senderPKey) {
+            expect(extMeta.senderPKey).withContext('correct sender\'s public key').toBe(msg.cryptoMeta.senderPKey);
+        }
+        expect(extMeta.objIds.length).withContext('correct number of message objects in meta').toBe(msg.msgObjs.length);
+        expect(Object.keys(meta.objs).length).withContext('correct number of message object sizes in meta').toBe(msg.msgObjs.length);
+        for (let i = 0; i < msg.msgObjs.length; i += 1) {
+            // check meta info for each object
+            let obj = msg.msgObjs[i];
+            let objId = obj.objId;
+            expect(extMeta.objIds[i]).toBe(objId);
+            expect(meta.objs[objId].size.header).withContext('header length of a message object').toBe(obj.header.length);
+            expect(meta.objs[objId].size.segments).withContext('segments length of a message object').toBe(obj.segs.length);
+            expect(meta.objs[objId].completed).withContext('completness flag of a message object').toBe(true);
+            // check object file
+            const filePath = (0, path_1.join)(msgFolder, objId);
+            const file = await obj_file_1.ObjVersionFile.forExisting(filePath)
+                .catch((exc) => {
+                if (exc.notFound) {
+                    return undefined;
+                }
+                throw exc;
+            });
+            if (!file) {
+                return false;
+            }
+            const headerInFile = await file.readHeader();
+            if (!headerInFile
+                || !(0, bytes_equal_1.bytesEqual)(headerInFile, obj.header)) {
+                return false;
+            }
+            const segsInFile = (0, buffer_utils_1.joinByteArrs)(await file.readSegs(0, file.getTotalSegsLen()));
+            if (!(0, bytes_equal_1.bytesEqual)(segsInFile, obj.segs)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.ASMailComponent = ASMailComponent;
+Object.freeze(ASMailComponent.prototype);
+Object.freeze(ASMailComponent);

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

@@ -0,0 +1,13 @@
+import { ServerRunner } from '../server-runner';
+import { Configurations } from '../../../services';
+import { DNSMock } from '../../../mock/dns';
+import { AppWithWSs } from '../../../lib-server/web-sockets/app';
+export declare abstract class Component extends ServerRunner {
+    protected conf: Configurations;
+    private signupDomains;
+    protected dataFolder: string;
+    dns: DNSMock;
+    constructor(conf: Configurations, signupDomains: string[], servicePort?: number, dataFolder?: string);
+    prepToRun(): Promise<AppWithWSs>;
+    clean(): Promise<void>;
+}