spec-3nweb-server 1.8.5 → 1.8.7

package/build/tests/protocols/3nstorage/owner/specs/get-current-obj.js

@@ -0,0 +1,269 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 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.specs = void 0;
+const test_utils_1 = require("../test-utils");
+const owner_1 = require("../../../../../lib-common/service-api/3nstorage/owner");
+const async_jasmine_1 = require("../../../../libs-for-tests/async-jasmine");
+const xhr_utils_1 = require("../../../../libs-for-tests/xhr-utils");
+const _3nstorage_1 = require("../../../../libs-for-tests/3nstorage");
+const requests_1 = require("../../../../shared-checks/requests");
+const random_node_1 = require("../../../../../lib-common/random-node");
+const url_1 = require("url");
+const json_copy_1 = require("../../../../libs-for-tests/json-copy");
+const bytes_equal_1 = require("../../../../libs-for-tests/bytes-equal");
+exports.specs = [];
+const description = 'Request to get current non-root object';
+const obj = {
+    objId: 'aaaa',
+    version: 1,
+    header: (0, random_node_1.bytesSync)(100),
+    segs: (0, random_node_1.bytesSync)(2345)
+};
+let reqOpts;
+let storageServer;
+let user;
+let sessionId;
+async function setStage(setup) {
+    storageServer = setup().storageServer;
+    user = setup().user;
+    await storageServer.restartAndClearStorageFor(user.id);
+    sessionId = await (0, test_utils_1.startSession)(user);
+    await (0, _3nstorage_1.saveObj)(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+    reqOpts = {
+        url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { header: true })),
+        method: 'GET',
+        sessionId,
+        responseType: 'arraybuffer',
+        responseHeaders: [
+            owner_1.HTTP_HEADER.objSegmentsLength, owner_1.HTTP_HEADER.objVersion,
+            owner_1.HTTP_HEADER.objHeaderLength
+        ]
+    };
+}
+function checkReplyExpectation(rep, obj, headerPresent, expectedSegsBytes) {
+    // status
+    expect(rep.status).withContext('status for returned bytes').toBe(owner_1.currentObj.SC.okGet);
+    // version header
+    expect(parseInt(rep.headers.get(owner_1.HTTP_HEADER.objVersion))).withContext('object version must be given in the reply header').toBe(obj.version);
+    // object's header length http header
+    const headerLen = obj.header.length;
+    if (headerPresent) {
+        expect(parseInt(rep.headers.get(owner_1.HTTP_HEADER.objHeaderLength))).withContext('object header size must be given in the reply header').toBe(headerLen);
+    }
+    // segments length header
+    const segsLen = (obj.diff ? obj.diff.segsSize : obj.segs.length);
+    expect(parseInt(rep.headers.get(owner_1.HTTP_HEADER.objSegmentsLength))).withContext('object segments size must be given in the reply header').toBe(segsLen);
+    // check body
+    if (headerPresent) {
+        expect((0, bytes_equal_1.bytesEqual)(rep.data.subarray(0, headerLen), obj.header)).withContext('reply should have header bytes at the front').toBe(true);
+        expect((0, bytes_equal_1.bytesEqual)(rep.data.subarray(headerLen), expectedSegsBytes)).withContext('reply should have proper segments bytes, following header bytes').toBe(true);
+    }
+    else {
+        expect((0, bytes_equal_1.bytesEqual)(rep.data, expectedSegsBytes)).withContext('reply should have proper segments bytes').toBe(true);
+    }
+}
+const readSimpleObjVersion = { description };
+exports.specs.push(readSimpleObjVersion);
+readSimpleObjVersion.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeAllAsync)(() => setStage(setup));
+    (0, async_jasmine_1.itAsync)('will not work outside of a valid session', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        await (0, requests_1.expectNonAcceptanceOfBadSessionId)(opts);
+    });
+    (0, async_jasmine_1.itAsync)('fails when object does not exist', async () => {
+        const unknownObj = 'unknown-obj';
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(unknownObj, { ofs: 0 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.currentObj.SC.unknownObj);
+    });
+    (0, async_jasmine_1.itAsync)('will not accept bad parameters', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { ofs: -34 }));
+        let rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { limit: -34 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { ofs: 10, limit: 0 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { header: true, ofs: 10 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+    });
+    (0, async_jasmine_1.itAsync)('returns header and all segments', async () => {
+        expect(await storageServer.currentObjExists(user.id, obj.objId, obj.version, obj)).withContext('object must be in serve\'s store').toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { header: true }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, true, obj.segs);
+    });
+    (0, async_jasmine_1.itAsync)('returns header without segments', async () => {
+        expect(await storageServer.currentObjExists(user.id, obj.objId, obj.version, obj)).withContext('object must be in serve\'s store').toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { header: true, limit: 0 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, true, new Uint8Array(0));
+    });
+    (0, async_jasmine_1.itAsync)('returns all segments without header', async () => {
+        expect(await storageServer.currentObjExists(user.id, obj.objId, obj.version, obj)).withContext('object must be in serve\'s store').toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs);
+    });
+    (0, async_jasmine_1.itAsync)('returns chunk, when offset and limit are given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        // with non-overflowing limit
+        for (let offset = 0; offset <= obj.segs.length; offset += 512) {
+            const chunkLen = Math.min(512, obj.segs.length - offset);
+            opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { ofs: offset, limit: chunkLen }));
+            const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+            checkReplyExpectation(rep, obj, false, obj.segs.subarray(offset, offset + chunkLen));
+        }
+        // with overflowing limit
+        const offset = obj.segs.length - 100;
+        const requestedLen = 300;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { ofs: offset, limit: requestedLen }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs.subarray(offset));
+    });
+    (0, async_jasmine_1.itAsync)('reads segments from start, when offset is not given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        // with non-overflowing length
+        const chunkLen = 512;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { limit: chunkLen }));
+        let rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs.subarray(0, chunkLen));
+        // with overflowing length
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { limit: obj.segs.length + 300 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs);
+    });
+    (0, async_jasmine_1.itAsync)('reads segments to the end, when limit is not given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { ofs: 1234 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs.subarray(1234));
+    });
+    (0, async_jasmine_1.itAsync)('no-bytes read', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(obj.objId, { ofs: obj.segs.length, limit: 500 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, new Uint8Array(0));
+    });
+});
+const diffVer = {
+    objId: obj.objId,
+    version: obj.version + 1,
+    header: (0, random_node_1.bytesSync)(111),
+    segs: (0, random_node_1.bytesSync)(1000),
+    diff: {
+        baseVersion: obj.version,
+        segsSize: 2000,
+        sections: [
+            [0, 25, 500],
+            [1, 0, 300],
+            [0, 525, 500],
+            [1, 300, 700]
+        ]
+    }
+};
+function combineDiffSegs(baseSegs, diffObj) {
+    if (!diffObj.diff) {
+        throw new Error(`object has no diff`);
+    }
+    const combined = Buffer.alloc(diffObj.diff.segsSize);
+    let offset = 0;
+    for (const s of diffObj.diff.sections) {
+        const src = ((s[0] === 0) ? baseSegs : diffObj.segs);
+        const chunk = src.subarray(s[1], s[1] + s[2]);
+        if (chunk.length !== s[2]) {
+            throw new Error('Given DiffInfo incorrectly references chunks of segments');
+        }
+        combined.set(chunk, offset);
+        offset += s[2];
+    }
+    if (offset !== diffObj.diff.segsSize) {
+        throw new Error('Given DiffInfo states incorrect segments length');
+    }
+    return combined;
+}
+const accessDiffedObjVersion = {
+    description: `${description}, access to version, saved as a diff, is the same, as to version saved as a whole`
+};
+exports.specs.push(accessDiffedObjVersion);
+accessDiffedObjVersion.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeAllAsync)(async () => {
+        await setStage(setup);
+        await (0, _3nstorage_1.saveObj)(user.storageOwnerUrl, sessionId, diffVer.objId, diffVer.version, diffVer);
+        reqOpts = {
+            url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(diffVer.objId, { header: true })),
+            method: 'GET',
+            sessionId,
+            responseType: 'arraybuffer',
+            responseHeaders: [
+                owner_1.HTTP_HEADER.objSegmentsLength, owner_1.HTTP_HEADER.objVersion,
+                owner_1.HTTP_HEADER.objHeaderLength
+            ]
+        };
+    });
+    (0, async_jasmine_1.itAsync)('returns header and all segments', async () => {
+        expect(await storageServer.currentObjExists(user.id, diffVer.objId, diffVer.version, diffVer)).withContext(`object must be in serve's store`).toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        const combinedBytes = combineDiffSegs(obj.segs, diffVer);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(diffVer.objId, { header: true }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, true, combinedBytes);
+    });
+    (0, async_jasmine_1.itAsync)('returns header without segments', async () => {
+        expect(await storageServer.currentObjExists(user.id, diffVer.objId, diffVer.version, diffVer)).withContext(`object must be in serve's store`).toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(diffVer.objId, { header: true, limit: 0 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, true, new Uint8Array(0));
+    });
+    (0, async_jasmine_1.itAsync)('returns all segments without header', async () => {
+        expect(await storageServer.currentObjExists(user.id, diffVer.objId, diffVer.version, diffVer)).withContext(`object must be in serve's store`).toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        const combinedBytes = combineDiffSegs(obj.segs, diffVer);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(diffVer.objId));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, false, combinedBytes);
+    });
+    (0, async_jasmine_1.itAsync)('returns chunk, when offset and limit are given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        const combinedBytes = combineDiffSegs(obj.segs, diffVer);
+        // with non-overflowing length
+        for (let offset = 0; offset <= diffVer.diff.segsSize; offset += 512) {
+            const chunkLen = Math.min(512, diffVer.diff.segsSize - offset);
+            opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(diffVer.objId, { ofs: offset, limit: chunkLen }));
+            const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+            checkReplyExpectation(rep, diffVer, false, combinedBytes.subarray(offset, offset + chunkLen));
+        }
+        // with overflowing length
+        const offset = combinedBytes.length - 100;
+        const requestedLen = 300;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.getReqUrlEnd(diffVer.objId, { ofs: offset, limit: requestedLen }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, false, combinedBytes.subarray(offset));
+    });
+});
+Object.freeze(exports);

package/build/tests/protocols/3nstorage/owner/specs/get-current-root.d.ts

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

package/build/tests/protocols/3nstorage/owner/specs/get-current-root.js

@@ -0,0 +1,262 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 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.specs = void 0;
+const test_utils_1 = require("../test-utils");
+const owner_1 = require("../../../../../lib-common/service-api/3nstorage/owner");
+const async_jasmine_1 = require("../../../../libs-for-tests/async-jasmine");
+const xhr_utils_1 = require("../../../../libs-for-tests/xhr-utils");
+const _3nstorage_1 = require("../../../../libs-for-tests/3nstorage");
+const requests_1 = require("../../../../shared-checks/requests");
+const random_node_1 = require("../../../../../lib-common/random-node");
+const url_1 = require("url");
+const json_copy_1 = require("../../../../libs-for-tests/json-copy");
+const bytes_equal_1 = require("../../../../libs-for-tests/bytes-equal");
+exports.specs = [];
+const description = 'Request to get current root object';
+const obj = {
+    objId: null,
+    version: 1,
+    header: (0, random_node_1.bytesSync)(100),
+    segs: (0, random_node_1.bytesSync)(2345)
+};
+let reqOpts;
+let storageServer;
+let user;
+let sessionId;
+async function setStage(setup) {
+    storageServer = setup().storageServer;
+    user = setup().user;
+    await storageServer.restartAndClearStorageFor(user.id);
+    sessionId = await (0, test_utils_1.startSession)(user);
+    await (0, _3nstorage_1.saveObj)(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+    reqOpts = {
+        url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ header: true })),
+        method: 'GET',
+        sessionId,
+        responseType: 'arraybuffer',
+        responseHeaders: [
+            owner_1.HTTP_HEADER.objSegmentsLength, owner_1.HTTP_HEADER.objVersion,
+            owner_1.HTTP_HEADER.objHeaderLength
+        ]
+    };
+}
+function checkReplyExpectation(rep, obj, headerPresent, expectedSegsBytes) {
+    // status
+    expect(rep.status).withContext('status for returned bytes').toBe(owner_1.currentRootObj.SC.okGet);
+    // version header
+    expect(parseInt(rep.headers.get(owner_1.HTTP_HEADER.objVersion))).withContext('object version must be given in the reply header').toBe(obj.version);
+    // object's header length http header
+    const headerLen = obj.header.length;
+    if (headerPresent) {
+        expect(parseInt(rep.headers.get(owner_1.HTTP_HEADER.objHeaderLength))).withContext('object header size must be given in the reply header').toBe(headerLen);
+    }
+    // segments length header
+    const segsLen = (obj.diff ? obj.diff.segsSize : obj.segs.length);
+    expect(parseInt(rep.headers.get(owner_1.HTTP_HEADER.objSegmentsLength))).withContext('object segments size must be given in the reply header').toBe(segsLen);
+    // check body
+    if (headerPresent) {
+        expect((0, bytes_equal_1.bytesEqual)(rep.data.subarray(0, headerLen), obj.header)).withContext('reply should have header bytes at the front').toBe(true);
+        expect((0, bytes_equal_1.bytesEqual)(rep.data.subarray(headerLen), expectedSegsBytes)).withContext('reply should have proper segments bytes, following header bytes').toBe(true);
+    }
+    else {
+        expect((0, bytes_equal_1.bytesEqual)(rep.data, expectedSegsBytes)).withContext('reply should have proper segments bytes').toBe(true);
+    }
+}
+const readSimpleObjVersion = { description };
+exports.specs.push(readSimpleObjVersion);
+readSimpleObjVersion.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeAllAsync)(() => setStage(setup));
+    (0, async_jasmine_1.itAsync)('will not work outside of a valid session', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        await (0, requests_1.expectNonAcceptanceOfBadSessionId)(opts);
+    });
+    (0, async_jasmine_1.itAsync)('will not accept bad parameters', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: -34 }));
+        let rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ limit: -34 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: 10, limit: 0 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ header: true, ofs: 10 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.ERR_SC.malformed);
+    });
+    (0, async_jasmine_1.itAsync)('returns header and all segments', async () => {
+        expect(await storageServer.currentRootObjExists(user.id, obj.version, obj)).withContext('object must be in serve\'s store').toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ header: true }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, true, obj.segs);
+    });
+    (0, async_jasmine_1.itAsync)('returns header without segments', async () => {
+        expect(await storageServer.currentRootObjExists(user.id, obj.version, obj)).withContext('object must be in serve\'s store').toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ header: true, limit: 0 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, true, new Uint8Array(0));
+    });
+    (0, async_jasmine_1.itAsync)('returns all segments without header', async () => {
+        expect(await storageServer.currentRootObjExists(user.id, obj.version, obj)).withContext('object must be in serve\'s store').toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd());
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs);
+    });
+    (0, async_jasmine_1.itAsync)('returns chunk, when offset and limit are given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        // with non-overflowing limit
+        for (let offset = 0; offset <= obj.segs.length; offset += 512) {
+            const chunkLen = Math.min(512, obj.segs.length - offset);
+            opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: offset, limit: chunkLen }));
+            const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+            checkReplyExpectation(rep, obj, false, obj.segs.subarray(offset, offset + chunkLen));
+        }
+        // with overflowing limit
+        const offset = obj.segs.length - 100;
+        const requestedLen = 300;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: offset, limit: requestedLen }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs.subarray(offset));
+    });
+    (0, async_jasmine_1.itAsync)('reads segments from start, when offset is not given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        // with non-overflowing length
+        const chunkLen = 512;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ limit: chunkLen }));
+        let rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs.subarray(0, chunkLen));
+        // with overflowing length
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ limit: obj.segs.length + 300 }));
+        rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs);
+    });
+    (0, async_jasmine_1.itAsync)('reads segments to the end, when limit is not given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: 1234 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, obj.segs.subarray(1234));
+    });
+    (0, async_jasmine_1.itAsync)('no-bytes read', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: obj.segs.length, limit: 500 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, obj, false, new Uint8Array(0));
+    });
+});
+const diffVer = {
+    objId: null,
+    version: obj.version + 1,
+    header: (0, random_node_1.bytesSync)(111),
+    segs: (0, random_node_1.bytesSync)(1000),
+    diff: {
+        baseVersion: obj.version,
+        segsSize: 2000,
+        sections: [
+            [0, 25, 500],
+            [1, 0, 300],
+            [0, 525, 500],
+            [1, 300, 700]
+        ]
+    }
+};
+function combineDiffSegs(baseSegs, diffObj) {
+    if (!diffObj.diff) {
+        throw new Error(`object has no diff`);
+    }
+    const combined = Buffer.alloc(diffObj.diff.segsSize);
+    let offset = 0;
+    for (const s of diffObj.diff.sections) {
+        const src = ((s[0] === 0) ? baseSegs : diffObj.segs);
+        const chunk = src.subarray(s[1], s[1] + s[2]);
+        if (chunk.length !== s[2]) {
+            throw new Error('Given DiffInfo incorrectly references chunks of segments');
+        }
+        combined.set(chunk, offset);
+        offset += s[2];
+    }
+    if (offset !== diffObj.diff.segsSize) {
+        throw new Error('Given DiffInfo states incorrect segments length');
+    }
+    return combined;
+}
+const accessDiffedObjVersion = {
+    description: `${description}, access to version, saved as a diff, is the same, as to version saved as a whole`
+};
+exports.specs.push(accessDiffedObjVersion);
+accessDiffedObjVersion.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeAllAsync)(async () => {
+        await setStage(setup);
+        await (0, _3nstorage_1.saveObj)(user.storageOwnerUrl, sessionId, diffVer.objId, diffVer.version, diffVer);
+        reqOpts = {
+            url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ header: true })),
+            method: 'GET',
+            sessionId,
+            responseType: 'arraybuffer',
+            responseHeaders: [
+                owner_1.HTTP_HEADER.objSegmentsLength, owner_1.HTTP_HEADER.objVersion,
+                owner_1.HTTP_HEADER.objHeaderLength
+            ]
+        };
+    });
+    (0, async_jasmine_1.itAsync)('returns header and all segments', async () => {
+        expect(await storageServer.currentRootObjExists(user.id, diffVer.version, diffVer)).withContext(`object must be in serve's store`).toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        const combinedBytes = combineDiffSegs(obj.segs, diffVer);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ header: true }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, true, combinedBytes);
+    });
+    (0, async_jasmine_1.itAsync)('returns header without segments', async () => {
+        expect(await storageServer.currentRootObjExists(user.id, diffVer.version, diffVer)).withContext(`object must be in serve's store`).toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ header: true, limit: 0 }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, true, new Uint8Array(0));
+    });
+    (0, async_jasmine_1.itAsync)('returns all segments without header', async () => {
+        expect(await storageServer.currentRootObjExists(user.id, diffVer.version, diffVer)).withContext(`object must be in serve's store`).toBe(true);
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        const combinedBytes = combineDiffSegs(obj.segs, diffVer);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd());
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, false, combinedBytes);
+    });
+    (0, async_jasmine_1.itAsync)('returns chunk, when offset and limit are given', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        const combinedBytes = combineDiffSegs(obj.segs, diffVer);
+        // with non-overflowing length
+        for (let offset = 0; offset <= diffVer.diff.segsSize; offset += 512) {
+            const chunkLen = Math.min(512, diffVer.diff.segsSize - offset);
+            opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: offset, limit: chunkLen }));
+            const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+            checkReplyExpectation(rep, diffVer, false, combinedBytes.subarray(offset, offset + chunkLen));
+        }
+        // with overflowing length
+        const offset = combinedBytes.length - 100;
+        const requestedLen = 300;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.getReqUrlEnd({ ofs: offset, limit: requestedLen }));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        checkReplyExpectation(rep, diffVer, false, combinedBytes.subarray(offset));
+    });
+});
+Object.freeze(exports);

package/build/tests/protocols/3nstorage/owner/specs/get-obj-status.d.ts

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

package/build/tests/protocols/3nstorage/owner/specs/get-obj-status.js

@@ -0,0 +1,79 @@
+"use strict";
+/*
+ Copyright (C) 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.specs = void 0;
+const test_utils_1 = require("../test-utils");
+const owner_1 = require("../../../../../lib-common/service-api/3nstorage/owner");
+const async_jasmine_1 = require("../../../../libs-for-tests/async-jasmine");
+const xhr_utils_1 = require("../../../../libs-for-tests/xhr-utils");
+const _3nstorage_1 = require("../../../../libs-for-tests/3nstorage");
+const requests_1 = require("../../../../shared-checks/requests");
+const random_node_1 = require("../../../../../lib-common/random-node");
+const url_1 = require("url");
+const json_copy_1 = require("../../../../libs-for-tests/json-copy");
+exports.specs = {
+    description: `Request to list object's archived versions`
+};
+const obj = {
+    objId: 'aaaa',
+    version: 1,
+    header: (0, random_node_1.bytesSync)(100),
+    segs: (0, random_node_1.bytesSync)(573)
+};
+exports.specs.definition = (setup) => (() => {
+    let reqOpts;
+    let storageServer;
+    let user;
+    let sessionId;
+    (0, async_jasmine_1.beforeAllAsync)(async () => {
+        storageServer = setup().storageServer;
+        user = setup().user;
+        await storageServer.restartAndClearStorageFor(user.id);
+        sessionId = await (0, test_utils_1.startSession)(user);
+        reqOpts = {
+            url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.objStatus.getReqUrlEnd(obj.objId)),
+            method: 'GET',
+            responseType: 'json',
+            sessionId
+        };
+    });
+    (0, async_jasmine_1.itAsync)('will not work outside of a valid session', async () => {
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        await (0, requests_1.expectNonAcceptanceOfBadSessionId)(opts);
+    });
+    (0, async_jasmine_1.itAsync)('fails when object does not exist', async () => {
+        const unknownObj = 'unknown-obj';
+        const opts = (0, json_copy_1.copy)(reqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.objStatus.getReqUrlEnd(unknownObj));
+        const rep = await (0, xhr_utils_1.doBodylessRequest)(opts);
+        expect(rep.status).toBe(owner_1.objStatus.SC.unknownObj);
+    });
+    (0, async_jasmine_1.itAsync)(`shows obj status with versions' info`, async () => {
+        await (0, _3nstorage_1.saveObj)(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+        let rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+        expect(rep.status).toBe(owner_1.objStatus.SC.ok);
+        expect(rep.data.current).toBe(1);
+        expect(rep.data.archived).toBeUndefined();
+        await (0, test_utils_1.archiveObjVer)(user, obj.objId, 1, sessionId);
+        rep = await (0, xhr_utils_1.doBodylessRequest)(reqOpts);
+        expect(rep.status).toBe(owner_1.objStatus.SC.ok);
+        expect(rep.data.current).toBe(1);
+        expect(rep.data.archived).toContain(1);
+    });
+});
+Object.freeze(exports);

package/build/tests/protocols/3nstorage/owner/specs/get-root-status.d.ts

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