spec-3nweb-server 1.8.4 → 1.8.6

package/build/tests/admin-proto/signup.js

@@ -0,0 +1,235 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2020 - 2021, 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 });
+const async_jasmine_1 = require("../libs-for-tests/async-jasmine");
+const admin_1 = require("../libs-for-tests/server-components/admin");
+const xhr_utils_1 = require("../libs-for-tests/xhr-utils");
+const signupApi = require("../../lib-common/admin-api/signup");
+const requests_1 = require("../shared-checks/requests");
+const jwkeys_1 = require("../../lib-common/jwkeys");
+const ecma_nacl_1 = require("ecma-nacl");
+describe('Admin', () => {
+    describe('signup subsystem', () => {
+        let admin;
+        const signupDomains = ['first.org', 'second.org'];
+        (0, async_jasmine_1.beforeEachAsync)(async () => {
+            admin = new admin_1.AdminComponent(signupDomains);
+            await admin.start();
+        });
+        (0, async_jasmine_1.afterEachAsync)(async () => {
+            await admin.stop();
+            admin = undefined;
+        });
+        (0, async_jasmine_1.itAsync)('tells available addresses for a given name', async () => {
+            const REQ_SIZE_LIMIT = 1024;
+            const name = 'Bob Marley ';
+            const reqOpts = {
+                url: admin.signupUrl + signupApi.availableAddressesForName.URL_END,
+                method: 'POST',
+                responseType: 'json'
+            };
+            // request with ok name
+            let req = { name };
+            const rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+            expect(rep.status).withContext('status code for OK reply').toBe(signupApi.availableAddressesForName.SC.ok);
+            expect(Array.isArray(rep.data)).withContext('OK reply is an array').toBe(true);
+            expect(rep.data.length).withContext('with no users, all domains should used as options for available addresses').toBe(signupDomains.length);
+            for (const domain of signupDomains) {
+                expect(rep.data).toContain(name + '@' + domain);
+            }
+            // requests with bad names and with bad json's
+            const badNames = [name + '@something',
+                5, null, undefined, {}]; // non-strings
+            const badJSONs = [name, 5, null, undefined, [name],
+                { a: 1 }];
+            for (const badName of badNames) {
+                req = { name: badName };
+                badJSONs.push(req);
+            }
+            await (0, requests_1.expectNonAcceptanceOfBadJsonRequest)(reqOpts, REQ_SIZE_LIMIT, badJSONs);
+        });
+        (0, async_jasmine_1.itAsync)('tells available domains', async () => {
+            const REQ_SIZE_LIMIT = 1024;
+            const reqOpts = {
+                url: admin.signupUrl + signupApi.availableDomains.URL_END,
+                method: 'POST',
+                responseType: 'json'
+            };
+            const req = {};
+            const rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+            expect(rep.status).withContext('status code for OK reply').toBe(signupApi.availableDomains.SC.ok);
+            expect(Array.isArray(rep.data)).withContext('OK reply is an array').toBe(true);
+            expect(rep.data.length).withContext('with no token, all domains should be given as options').toBe(signupDomains.length);
+            for (const domain of signupDomains) {
+                expect(rep.data).toContain(domain);
+            }
+            // requests with bad json's
+            const badJSONs = [{ signupToken: 4 }];
+            await (0, requests_1.expectNonAcceptanceOfBadJsonRequest)(reqOpts, REQ_SIZE_LIMIT, badJSONs);
+        });
+        async function getAvailableAddressesFor(name) {
+            const reqOpts = {
+                url: admin.signupUrl + signupApi.availableAddressesForName.URL_END,
+                method: 'POST',
+                responseType: 'json'
+            };
+            const req = { name };
+            const rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+            expect(rep.status).toBe(signupApi.availableAddressesForName.SC.ok);
+            return rep.data;
+        }
+        function makeAddUserReq(userId, signupToken) {
+            return {
+                userId,
+                storage: {
+                    kdParams: {}
+                },
+                mailerId: {
+                    defaultPKey: {
+                        pkey: {
+                            alg: ecma_nacl_1.box.JWK_ALG_NAME,
+                            kid: (Buffer.alloc(12)).toString('base64'),
+                            use: jwkeys_1.use.MID_PKLOGIN,
+                            k: (Buffer.alloc(ecma_nacl_1.box.KEY_LENGTH)).toString('base64')
+                        },
+                        kdParams: {}
+                    },
+                    otherPKeys: [{
+                            alg: ecma_nacl_1.box.JWK_ALG_NAME,
+                            kid: (Buffer.alloc(12)).toString('base64'),
+                            use: jwkeys_1.use.MID_PKLOGIN,
+                            k: (Buffer.alloc(ecma_nacl_1.box.KEY_LENGTH)).toString('base64')
+                        }]
+                },
+                signupToken
+            };
+        }
+        function makeBadAddUserReq(goodId) {
+            const name = 'Bob Marley';
+            const badJSONs = [name, 5, null, undefined, [name],
+                { a: 1 }];
+            const badIds = ['bad domain str',
+                '', ' ', '\t', '\n',
+                5, null, undefined, {}]; // non-strings
+            for (const id of badIds) {
+                const req = makeAddUserReq(id);
+                badJSONs.push(req);
+            }
+            let req = makeAddUserReq(goodId);
+            delete req.userId;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.storage;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.storage.kdParams;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.defaultPKey;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.defaultPKey.pkey.alg;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.defaultPKey.pkey.k;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.defaultPKey.pkey.kid;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.defaultPKey.pkey.use;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.defaultPKey.kdParams;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.otherPKeys;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            req.mailerId.otherPKeys.shift();
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.otherPKeys[0].alg;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.otherPKeys[0].k;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.otherPKeys[0].kid;
+            badJSONs.push(req);
+            req = makeAddUserReq(goodId);
+            delete req.mailerId.otherPKeys[0].use;
+            badJSONs.push(req);
+            return badJSONs;
+        }
+        async function addNewUser(userId, signupToken) {
+            const reqOpts = {
+                url: admin.signupUrl + signupApi.addUser.URL_END,
+                method: 'POST'
+            };
+            const req = makeAddUserReq(userId, signupToken);
+            let rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+            expect(rep.status).withContext('status when user is added').toBe(signupApi.addUser.SC.ok);
+            rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+            expect(rep.status).withContext('status when user already exists').toBe(signupApi.addUser.SC.userAlreadyExists);
+        }
+        (0, async_jasmine_1.itAsync)('adds new user', async () => {
+            const REQ_SIZE_LIMIT = 4 * 1024;
+            const reqOpts = {
+                url: admin.signupUrl + signupApi.addUser.URL_END,
+                method: 'POST'
+            };
+            const name = 'Bob Marley ';
+            let addresses = await getAvailableAddressesFor(name);
+            let numOfAvailableAddresses = addresses.length;
+            expect(numOfAvailableAddresses).toBe(signupDomains.length);
+            // requests with bad json's
+            const badJSONs = makeBadAddUserReq(addresses[0]);
+            await (0, requests_1.expectNonAcceptanceOfBadJsonRequest)(reqOpts, REQ_SIZE_LIMIT, badJSONs);
+            // normal adding users
+            for (const userId of addresses) {
+                expect(addresses).toContain(userId);
+                await addNewUser(userId);
+                numOfAvailableAddresses -= 1;
+                addresses = await getAvailableAddressesFor(name);
+                expect(addresses.length).toBe(numOfAvailableAddresses);
+                expect(addresses).not.toContain(userId);
+            }
+        });
+        (0, async_jasmine_1.itAsync)(`adds new user with token`, async () => {
+            const reqOpts = {
+                url: admin.signupUrl + signupApi.addUser.URL_END,
+                method: 'POST'
+            };
+            // note that new id has other domain that isn't set anywhere
+            const userId = 'Pink Floyd @home.town';
+            // let's try to do this without any token
+            let req = makeAddUserReq(userId);
+            let rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+            expect(rep.status).withContext('status when no token given').toBe(signupApi.addUser.SC.unauthorized);
+            // create token, here setup code uses spec-server specific code
+            const token = await admin.createSingleUserSignupTokenFor(userId);
+            req = makeAddUserReq(userId, token);
+            rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+            expect(rep.status).withContext('status when user is added').toBe(signupApi.addUser.SC.ok);
+        });
+    });
+});

package/build/tests/jasmine.d.ts

@@ -0,0 +1 @@
+declare const jas: any;

package/build/tests/jasmine.js

@@ -0,0 +1,32 @@
+/*
+ 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/>.
+*/
+// NOTE: due to bad definition file, typescript below is not very type-strict.
+const jas = new (require('jasmine'))();
+jas.loadConfig({
+    spec_dir: 'build/tests',
+    spec_files: [
+        'admin-proto/**/*.js',
+        'protocols/mailerid.js',
+        'protocols/3nstorage/*.js',
+        'protocols/asmail/*.js',
+    ],
+    random: false
+});
+jas.configureDefaultReporter({
+    showColors: true
+});
+jas.execute();

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

@@ -0,0 +1,22 @@
+import * as api from '../../lib-common/service-api/3nstorage/owner';
+export declare function get3NStorageServiceUrl(storageUrl: string, service: 'owner' | 'shared'): Promise<string>;
+export interface BaseObj {
+    objId: string;
+    header: Uint8Array;
+    segs: Uint8Array;
+}
+export interface Obj extends BaseObj {
+    version: number;
+    diff?: api.DiffInfo;
+}
+export declare function cancelTransaction(ownerUrl: string, sessionId: string, objId: string, transactionId: string): Promise<void>;
+export declare function getSessionParams(ownerUrl: string, sessionId: string): Promise<api.sessionParams.Reply>;
+/**
+ * @param user
+ * @param objId is object's id. Null stands for root object.
+ * @param ver
+ * @param obj
+ * @return a promise, resolvable object is writen.
+ */
+export declare function saveObj(ownerUrl: string, sessionId: string, objId: string | null, ver: number, obj: Obj): Promise<void>;
+export declare function removeObj(ownerUrl: string, sessionId: string, objId: string): Promise<void>;

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

@@ -0,0 +1,123 @@
+"use strict";
+/*
+ Copyright (C) 2016, 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.removeObj = exports.saveObj = exports.getSessionParams = exports.cancelTransaction = exports.get3NStorageServiceUrl = void 0;
+const xhr_utils_1 = require("./xhr-utils");
+const url_1 = require("url");
+const api = require("../../lib-common/service-api/3nstorage/owner");
+const buffer_utils_1 = require("../../lib-common/buffer-utils");
+const assert_1 = require("./assert");
+async function get3NStorageServiceUrl(storageUrl, service) {
+    let reqOpts = {
+        url: storageUrl,
+        method: 'GET',
+        responseType: 'json'
+    };
+    let rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+    (0, assert_1.assert)(rep.status === 200);
+    let serviceUrl = rep.data[service];
+    (0, assert_1.assert)(typeof serviceUrl === 'string');
+    return (0, url_1.resolve)(storageUrl, serviceUrl);
+}
+exports.get3NStorageServiceUrl = get3NStorageServiceUrl;
+async function cancelTransaction(ownerUrl, sessionId, objId, transactionId) {
+    let url = (0, url_1.resolve)(ownerUrl, ((objId === null) ?
+        api.cancelRootTransaction.getReqUrlEnd(transactionId) :
+        api.cancelTransaction.getReqUrlEnd(objId, transactionId)));
+    let reqOpts = {
+        url,
+        method: 'POST',
+        sessionId
+    };
+    let rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+    (0, assert_1.assert)(rep.status === api.cancelTransaction.SC.ok, `Obj transaction isn't canceled: server status ${rep.status} instead of expected ${api.cancelTransaction.SC.ok}`);
+}
+exports.cancelTransaction = cancelTransaction;
+async function getSessionParams(ownerUrl, sessionId) {
+    let reqOpts = {
+        url: (0, url_1.resolve)(ownerUrl, api.sessionParams.URL_END),
+        method: 'GET',
+        responseType: 'json',
+        sessionId
+    };
+    let rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+    (0, assert_1.assert)(rep.status === 200);
+    return rep.data;
+}
+exports.getSessionParams = getSessionParams;
+/**
+ * @param user
+ * @param objId is object's id. Null stands for root object.
+ * @param ver
+ * @param obj
+ * @return a promise, resolvable object is writen.
+ */
+async function saveObj(ownerUrl, sessionId, objId, ver, obj) {
+    const header = obj.header.length;
+    const diffBytes = (obj.diff ?
+        buffer_utils_1.utf8.pack(JSON.stringify(obj.diff)) : undefined);
+    const diff = (diffBytes ? diffBytes.length : undefined);
+    const opts = {
+        method: 'PUT',
+        responseType: 'json',
+        sessionId
+    };
+    if (diffBytes) {
+        const urlEnd = (objId ?
+            api.currentObj.firstPutReqUrlEnd(objId, { ver, diff, header }) :
+            api.currentRootObj.firstPutReqUrlEnd({ ver, diff, header }));
+        opts.url = (0, url_1.resolve)(ownerUrl, urlEnd);
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [diffBytes, obj.header]);
+        (0, assert_1.assert)(rep.status === api.currentObj.SC.okPut, `Obj header isn't saved: server status ${rep.status} instead of expected ${api.currentObj.SC.okPut}`);
+        const trans = rep.data.transactionId;
+        let ofs = 0;
+        for (const [isNew, dOfs, len] of obj.diff.sections) {
+            const last = ((dOfs + len) === obj.segs.length);
+            if (isNew === 1) {
+                const urlEnd = (objId ?
+                    api.currentObj.secondPutReqUrlEnd(objId, { ofs, trans, last }) :
+                    api.currentRootObj.secondPutReqUrlEnd({ ofs, trans, last }));
+                opts.url = (0, url_1.resolve)(ownerUrl, urlEnd);
+                const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, obj.segs.subarray(dOfs, dOfs + len));
+                (0, assert_1.assert)(rep.status === api.currentObj.SC.okPut, `Obj segments sections isn't saved: server status ${rep.status} instead of expected ${api.currentObj.SC.okPut}`);
+            }
+            ofs += len;
+        }
+    }
+    else {
+        const urlOpts = { ver, header, last: true };
+        const urlEnd = (objId ?
+            api.currentObj.firstPutReqUrlEnd(objId, urlOpts) :
+            api.currentRootObj.firstPutReqUrlEnd(urlOpts));
+        opts.url = (0, url_1.resolve)(ownerUrl, urlEnd);
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [obj.header, obj.segs]);
+        (0, assert_1.assert)(rep.status === api.currentObj.SC.okPut, `Complete obj isn't saved: server status ${rep.status} instead of expected ${api.currentObj.SC.okPut}`);
+    }
+}
+exports.saveObj = saveObj;
+async function removeObj(ownerUrl, sessionId, objId) {
+    const opts = {
+        url: (0, url_1.resolve)(ownerUrl, api.currentObj.getReqUrlEnd(objId)),
+        method: 'DELETE',
+        sessionId
+    };
+    const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+    (0, assert_1.assert)(rep.status === api.currentObj.SC.okDelete, `Obj isn't removed: server status ${rep.status} instead of expected ${api.currentObj.SC.okDelete}`);
+}
+exports.removeObj = removeObj;
+Object.freeze(exports);

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

@@ -0,0 +1,22 @@
+import { User } from './mailerid';
+import { p } from '../../lib-common/service-api/asmail/config';
+import * as deliveryApi from '../../lib-common/service-api/asmail/delivery';
+import { BaseObj as Obj } from './3nstorage';
+export { BaseObj as Obj } from './3nstorage';
+export declare function getASMailServiceUrl(asmailUrl: string, service: 'delivery' | 'retrieval' | 'config'): Promise<string>;
+export declare function setInboxParams(asmailUrl: string, user: User, params: {
+    [pUrl: string]: any;
+}): Promise<void>;
+export declare const PUBLIC_KEY_USE = "asmail-pub-key";
+export declare function generateInitPubKey(midUrl: string, user: User): Promise<p.initPubKey.Certs>;
+export declare function startMsgDeliverySession(deliveryUrl: string, req: deliveryApi.sessionStart.Request): Promise<deliveryApi.sessionStart.Reply>;
+export interface DeliveryInfo extends deliveryApi.msgMeta.Reply, deliveryApi.sessionStart.Reply {
+}
+export declare function startMsgDelivery(deliveryUrl: string, firstReq: deliveryApi.sessionStart.Request, metaReq: deliveryApi.msgMeta.Request): Promise<DeliveryInfo>;
+export declare function sendMsgObj(deliveryUrl: string, sessionId: string, obj: Obj, chunkLimit: number | undefined): Promise<void>;
+export interface Msg {
+    cryptoMeta: deliveryApi.msgMeta.CryptoInfo;
+    msgObjs: Obj[];
+}
+export declare function sendMsg(deliveryUrl: string, recipient: string, msg: Msg): Promise<string>;
+export declare function msgSendingSteps(deliveryUrl: string, recipient: string, msg: Msg): AsyncGenerator<string, string, unknown>;

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

@@ -0,0 +1,179 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2019, 2022 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.msgSendingSteps = exports.sendMsg = exports.sendMsgObj = exports.startMsgDelivery = exports.startMsgDeliverySession = exports.generateInitPubKey = exports.PUBLIC_KEY_USE = exports.setInboxParams = exports.getASMailServiceUrl = void 0;
+const mailerid_1 = require("./mailerid");
+const xhr_utils_1 = require("./xhr-utils");
+const url_1 = require("url");
+const config_1 = require("../../lib-common/service-api/asmail/config");
+const random = require("../../lib-common/random-node");
+const buffer_utils_1 = require("../../lib-common/buffer-utils");
+const ecma_nacl_1 = require("ecma-nacl");
+const deliveryApi = require("../../lib-common/service-api/asmail/delivery");
+const assert_1 = require("./assert");
+async function getASMailServiceUrl(asmailUrl, service) {
+    const reqOpts = {
+        url: asmailUrl,
+        method: 'GET',
+        responseType: 'json'
+    };
+    const rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+    expect(rep.status).toBe(200);
+    const serviceUrl = rep.data[service];
+    expect(typeof serviceUrl).toBe('string');
+    return (0, url_1.resolve)(asmailUrl, serviceUrl);
+}
+exports.getASMailServiceUrl = getASMailServiceUrl;
+async function setInboxParams(asmailUrl, user, params) {
+    const confUrl = await getASMailServiceUrl(asmailUrl, 'config');
+    const sessionId = await (0, mailerid_1.doMailerIdLogin)((0, url_1.resolve)(confUrl, config_1.midLogin.URL_PART), user);
+    for (const pUrl of Object.keys(params)) {
+        const reqOpts = {
+            url: (0, url_1.resolve)(confUrl, pUrl),
+            method: 'PUT',
+            sessionId
+        };
+        const rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, params[pUrl]);
+        expect(rep.status).toBe(config_1.PARAM_SC.ok);
+    }
+}
+exports.setInboxParams = setInboxParams;
+exports.PUBLIC_KEY_USE = 'asmail-pub-key';
+async function generateInitPubKey(midUrl, user) {
+    const midSigner = await (0, mailerid_1.provisionMidSigner)(midUrl, user);
+    const skeyBytes = await random.bytes(ecma_nacl_1.box.KEY_LENGTH);
+    const pkeyBytes = ecma_nacl_1.box.generate_pubkey(skeyBytes);
+    const pkey = {
+        use: exports.PUBLIC_KEY_USE,
+        alg: ecma_nacl_1.box.JWK_ALG_NAME,
+        kid: await random.stringOfB64Chars(10),
+        k: buffer_utils_1.base64.pack(pkeyBytes)
+    };
+    const pkeyCert = midSigner.certifyPublicKey(pkey, 30 * 24 * 60 * 60);
+    const certs = {
+        pkeyCert,
+        provCert: midSigner.providerCert,
+        userCert: midSigner.userCert
+    };
+    return certs;
+}
+exports.generateInitPubKey = generateInitPubKey;
+async function startMsgDeliverySession(deliveryUrl, req) {
+    const reqOpts = {
+        url: (0, url_1.resolve)(deliveryUrl, deliveryApi.sessionStart.URL_END),
+        method: 'POST',
+        responseType: 'json'
+    };
+    const rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, req);
+    expect(rep.status).toBe(deliveryApi.sessionStart.SC.ok);
+    return rep.data;
+}
+exports.startMsgDeliverySession = startMsgDeliverySession;
+async function startMsgDelivery(deliveryUrl, firstReq, metaReq) {
+    const info = (await startMsgDeliverySession(deliveryUrl, firstReq));
+    const reqOpts = {
+        url: (0, url_1.resolve)(deliveryUrl, deliveryApi.msgMeta.URL_END),
+        method: 'PUT',
+        responseType: 'json',
+        sessionId: info.sessionId
+    };
+    const rep = await (0, xhr_utils_1.doJsonRequest)(reqOpts, metaReq);
+    expect(rep.status).toBe(deliveryApi.msgMeta.SC.ok);
+    for (const field of Object.keys(rep.data)) {
+        info[field] = rep.data[field];
+    }
+    return info;
+}
+exports.startMsgDelivery = startMsgDelivery;
+async function sendMsgObj(deliveryUrl, sessionId, obj, chunkLimit) {
+    if (!obj.objId) {
+        throw new Error(`Message object doesn't have an id`);
+    }
+    if (!chunkLimit) {
+        chunkLimit = 512 * 1024;
+    }
+    let ofs = 0;
+    const segsLen = obj.segs.length;
+    while (ofs < segsLen) {
+        const reqOpts = { url: '', method: 'PUT', sessionId };
+        let bytesToSend;
+        if (ofs === 0) {
+            // first request starts with header
+            const header = obj.header.length;
+            const segsChunk = obj.segs.subarray(0, chunkLimit - header);
+            const last = (segsChunk.length === obj.segs.length);
+            bytesToSend = [obj.header, segsChunk];
+            reqOpts.url = (0, url_1.resolve)(deliveryUrl, deliveryApi.msgObj.firstPutReqUrlEnd(obj.objId, { header, last }));
+            ofs += segsChunk.length;
+        }
+        else {
+            // second request(s) send bytes
+            bytesToSend = obj.segs.subarray(ofs, ofs + chunkLimit);
+            const last = ((ofs + bytesToSend.length) === obj.segs.length);
+            reqOpts.url = (0, url_1.resolve)(deliveryUrl, deliveryApi.msgObj.secondPutReqUrlEnd(obj.objId, { ofs, last }));
+            ofs += bytesToSend.length;
+        }
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(reqOpts, bytesToSend);
+        (0, assert_1.assert)(rep.status === deliveryApi.msgObj.SC.ok, `Msg obj isn't saved: server status ${rep.status} instead of expected ${deliveryApi.msgObj.SC.ok}`);
+    }
+}
+exports.sendMsgObj = sendMsgObj;
+async function sendMsg(deliveryUrl, recipient, msg) {
+    const stepsIter = msgSendingSteps(deliveryUrl, recipient, msg);
+    const fstStep = await stepsIter.next();
+    expect(fstStep.done).toBeFalsy();
+    expect(fstStep.value).toBeDefined();
+    const msgId = fstStep.value;
+    let done;
+    do {
+        done = !!(await stepsIter.next()).done;
+    } while (!done);
+    return msgId;
+}
+exports.sendMsg = sendMsg;
+async function* msgSendingSteps(deliveryUrl, recipient, msg) {
+    const meta = makeMetaFor(msg);
+    const sessInfo = await startMsgDelivery(deliveryUrl, { recipient }, meta);
+    yield sessInfo.msgId;
+    for (const msgObj of msg.msgObjs) {
+        await sendMsgObj(deliveryUrl, sessInfo.sessionId, msgObj, sessInfo.maxChunkSize);
+        yield sessInfo.msgId;
+    }
+    const reqOpts = {
+        url: (0, url_1.resolve)(deliveryUrl, deliveryApi.completion.URL_END),
+        method: 'POST',
+        sessionId: sessInfo.sessionId
+    };
+    const rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+    expect(rep.status).toBe(deliveryApi.completion.SC.ok);
+    return sessInfo.msgId;
+}
+exports.msgSendingSteps = msgSendingSteps;
+function makeMetaFor(msg) {
+    const meta = msg.cryptoMeta;
+    meta.objIds = [];
+    for (let i = 0; i < msg.msgObjs.length; i += 1) {
+        const objId = msg.msgObjs[i].objId;
+        if (!objId) {
+            throw new Error(`Message object #${i} doesn't have an id`);
+        }
+        meta.objIds[i] = objId;
+    }
+    return meta;
+}
+Object.freeze(exports);

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

@@ -0,0 +1 @@
+export declare function assert(ok: boolean, errMsg?: string): void;

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

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ Copyright(c) 2018 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.assert = void 0;
+function assert(ok, errMsg) {
+    if (!ok) {
+        throw new Error(errMsg);
+    }
+}
+exports.assert = assert;
+Object.freeze(exports);

package/build/tests/libs-for-tests/async-jasmine.d.ts

@@ -0,0 +1,7 @@
+export declare function itAsync(expectation: string, assertion?: () => Promise<void>, timeout?: number): void;
+export declare function xitAsync(expectation: string, assertion?: () => Promise<void>, timeout?: number): void;
+export declare function fitAsync(expectation: string, assertion?: () => Promise<void>, timeout?: number): void;
+export declare function beforeAllAsync(action: () => Promise<void>, timeout?: number): void;
+export declare function afterAllAsync(action: () => Promise<void>, timeout?: number): void;
+export declare function beforeEachAsync(action: () => Promise<void>, timeout?: number): void;
+export declare function afterEachAsync(action: () => Promise<void>, timeout?: number): void;