spec-3nweb-server 1.8.5 → 1.8.7

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

@@ -0,0 +1,72 @@
+"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: null,
+    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.rootStatus.getReqUrlEnd()),
+            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)(`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.rootStatus.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.rootStatus.SC.ok);
+        expect(rep.data.current).toBe(1);
+        expect(rep.data.archived).toContain(1);
+    });
+});
+Object.freeze(exports);

package/build/tests/protocols/3nstorage/owner/specs/put-current-obj.d.ts

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

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

@@ -0,0 +1,287 @@
+"use strict";
+/*
+ Copyright (C) 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 buffer_utils_1 = require("../../../../../lib-common/buffer-utils");
+const url_1 = require("url");
+const json_copy_1 = require("../../../../libs-for-tests/json-copy");
+exports.specs = [];
+const description = `Request to save non-root object`;
+const objV1 = {
+    objId: 'aaaa',
+    version: 1,
+    header: (0, random_node_1.bytesSync)(100),
+    segs: (0, random_node_1.bytesSync)(2345)
+};
+const objV2 = {
+    objId: objV1.objId,
+    version: objV1.version + 1,
+    header: (0, random_node_1.bytesSync)(110),
+    segs: (0, random_node_1.bytesSync)(6543)
+};
+let fstReqOpts;
+let sndReqOpts;
+let storageServer;
+let user;
+let sessionId;
+async function setupSession(setup) {
+    storageServer = setup().storageServer;
+    user = setup().user;
+    await storageServer.restartAndClearStorageFor(user.id);
+    sessionId = await (0, test_utils_1.startSession)(user);
+    fstReqOpts = {
+        url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV1.objId, { ver: 1, header: objV1.header.length })),
+        method: 'PUT',
+        responseType: 'json',
+        sessionId
+    };
+    sndReqOpts = {
+        url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd(objV1.objId, { trans: 'some-trans', ofs: 0 })),
+        method: 'PUT',
+        responseType: 'json',
+        sessionId
+    };
+}
+const fuzzingSpec = { description };
+exports.specs.push(fuzzingSpec);
+fuzzingSpec.definition = (setup) => (() => {
+    let maxChunkSize;
+    (0, async_jasmine_1.beforeEachAsync)(async () => {
+        await setupSession(setup);
+        const params = await (0, _3nstorage_1.getSessionParams)(user.storageOwnerUrl, sessionId);
+        maxChunkSize = params.maxChunkSize;
+    });
+    (0, async_jasmine_1.itAsync)('fails for object id not from bas64 url-safe alphabet', async () => {
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd('unknown+obj', { ver: 1, header: objV1.header.length, last: true }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+        expect(rep.status).withContext('status for but object id').toBe(owner_1.ERR_SC.malformed);
+    });
+    (0, async_jasmine_1.itAsync)('fails write for incorrect version', async () => {
+        await (0, _3nstorage_1.saveObj)(user.storageOwnerUrl, sessionId, objV1.objId, objV1.version, objV1);
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV1.objId, {
+            ver: objV1.version + 5, header: objV1.header.length, last: true
+        }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+        expect(rep.status).toBe(owner_1.currentObj.SC.mismatchedObjVer);
+        expect(typeof rep.data).toBe('object');
+        expect(rep.data.current_version).toBe(objV1.version);
+    });
+    (0, async_jasmine_1.itAsync)('fails for unknown object, without create flag', async () => {
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd('unknown-obj', { ver: 67, header: objV1.header.length, last: true }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+        expect(rep.status).withContext('status for unknown object').toBe(owner_1.currentObj.SC.unknownObj);
+    });
+    (0, async_jasmine_1.itAsync)('fails for unknown object, in secondary put request', async () => {
+        const opts = (0, json_copy_1.copy)(sndReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd('unknown-obj', { trans: 'some-trans', ofs: 0 }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, objV1.segs);
+        expect(rep.status).withContext('status for unknown object').toBe(owner_1.currentObj.SC.unknownObj);
+    });
+    (0, async_jasmine_1.itAsync)('fails for incorrect transaction, in secondary put', async () => {
+        const repToFstReq = await (0, xhr_utils_1.doBinaryRequest)(fstReqOpts, objV1.header);
+        expect(repToFstReq.status).toBe(owner_1.currentObj.SC.okPut);
+        const trans = repToFstReq.data.transactionId + ' - unknown';
+        const opts = (0, json_copy_1.copy)(sndReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd(objV1.objId, { trans, ofs: 0 }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, objV1.segs);
+        expect(rep.status).withContext('status for unknown transaction').toBe(owner_1.currentObj.SC.unknownTransaction);
+    });
+    (0, async_jasmine_1.itAsync)('will not accept bad type', async () => {
+        await (0, requests_1.expectNonAcceptanceOfBadType)(fstReqOpts, 'application/octet-stream', objV1.segs);
+        await (0, requests_1.expectNonAcceptanceOfBadType)(sndReqOpts, 'application/octet-stream', objV1.segs);
+    });
+    (0, async_jasmine_1.itAsync)('will not work outside of a valid session', async () => {
+        await (0, requests_1.expectNonAcceptanceOfBadSessionId)(fstReqOpts);
+        await (0, requests_1.expectNonAcceptanceOfBadSessionId)(sndReqOpts);
+    });
+    (0, async_jasmine_1.itAsync)('first request is limited by session parameter', async () => {
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV1.objId, { ver: objV1.version, header: 100, last: true }));
+        await (0, requests_1.expectNonAcceptanceOfLongBody)(opts, 'application/octet-stream', maxChunkSize + 100);
+    });
+    (0, async_jasmine_1.itAsync)('second request is limited by session parameter', async () => {
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV1.objId, { ver: objV1.version, header: objV1.header.length }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, objV1.header);
+        const trans = rep.data.transactionId;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd(objV1.objId, { trans, ofs: 0, last: true }));
+        await (0, requests_1.expectNonAcceptanceOfLongBody)(opts, 'application/octet-stream', maxChunkSize + 100);
+    });
+});
+const specsForNonDiffSending = {
+    description: `${description}, non-diff version,`
+};
+exports.specs.push(specsForNonDiffSending);
+specsForNonDiffSending.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeEachAsync)(() => setupSession(setup));
+    (0, async_jasmine_1.itAsync)(`writes whole object in one request`, async () => {
+        expect(await storageServer.currentObjExists(user.id, objV1.objId)).withContext('initially, there is no object').toBeFalsy();
+        // create object
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV1.objId, {
+            ver: objV1.version, header: objV1.header.length, last: true
+        }));
+        let rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+        expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+        expect(rep.data.transactionId).toBeUndefined();
+        expect(await storageServer.currentObjExists(user.id, objV1.objId, objV1.version, objV1)).withContext('first version of object is present on the server').toBeTruthy();
+        // upload object's next version
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV2.objId, { ver: objV2.version, header: objV2.header.length, last: true }));
+        rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV2.header, objV2.segs]);
+        expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+        expect(rep.data.transactionId).toBeUndefined();
+        expect(await storageServer.currentObjExists(user.id, objV2.objId, objV2.version, objV2)).withContext('second version of object is present on the server').toBeTruthy();
+        expect(await storageServer.transactionExists(user.id, objV2.objId)).toBeFalsy();
+        // returns current version, when trying to upload incorrect version,
+        // like uploading existing version, or smaller
+        const errRep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV2.header, objV2.segs]);
+        expect(errRep.status).withContext('status for mismatched upload version').toBe(owner_1.currentObj.SC.mismatchedObjVer);
+        expect(errRep.data.current_version).withContext('current object version on server').toBe(objV2.version);
+    });
+    (0, async_jasmine_1.itAsync)(`writes object in several requests`, async () => {
+        expect(await storageServer.currentObjExists(user.id, objV1.objId)).withContext('initially, there is no object').toBeFalsy();
+        // create object
+        // first request, to start transmission
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV1.objId, { ver: objV1.version, header: objV1.header.length }));
+        let rep = await (0, xhr_utils_1.doBinaryRequest)(opts, objV1.header);
+        expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+        expect(typeof rep.data.transactionId).toBe('string');
+        let transactionId = rep.data.transactionId;
+        expect(await storageServer.transactionExists(user.id, objV1.objId, transactionId)).withContext(`transaction should be open, cause not all bytes have been sent in the first request`).toBeTruthy();
+        expect(await storageServer.currentObjExists(user.id, objV1.objId, objV1.version)).withContext('upload is not complete, as transaction is not closed').toBeFalsy();
+        // following requests
+        for (let offset = 0; offset < objV1.segs.length; offset += 512) {
+            const last = ((offset + 512) >= objV1.segs.length);
+            if (last) {
+                opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd(objV1.objId, { trans: transactionId, ofs: offset, last: true }));
+                const chunk = objV1.segs.subarray(offset, offset + 512);
+                const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+                expect(rep.data.transactionId).toBeUndefined();
+            }
+            else {
+                opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd(objV1.objId, { trans: transactionId, ofs: offset }));
+                const chunk = objV1.segs.subarray(offset, offset + 512);
+                const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+                expect(rep.data.transactionId).toBe(transactionId);
+            }
+        }
+        expect(await storageServer.currentObjExists(user.id, objV1.objId, objV1.version, objV1)).withContext('first version of object is present on the server').toBeTruthy();
+        expect(await storageServer.transactionExists(user.id, objV1.objId)).toBeFalsy();
+    });
+});
+const diffVer = {
+    objId: objV1.objId,
+    version: objV1.version + 1,
+    header: (0, random_node_1.bytesSync)(111),
+    segs: (0, random_node_1.bytesSync)(1000),
+    diff: {
+        baseVersion: 1,
+        segsSize: 1200,
+        sections: [
+            [0, 25, 100],
+            [1, 0, 300],
+            [0, 125, 100],
+            [1, 300, 700]
+        ]
+    }
+};
+const specsForDiffTransaction = {
+    description: `${description}, diff version,`
+};
+exports.specs.push(specsForDiffTransaction);
+specsForDiffTransaction.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeEachAsync)(async () => {
+        await setupSession(setup);
+        // upload first object version
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(objV1.objId, {
+            ver: objV1.version, header: objV1.header.length, last: true
+        }));
+        await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+    });
+    // XXX can't write general diff-ed object in one request.
+    // itAsync(`writes whole object in one request`, async () => {
+    // 	expect(await storageServer.currentObjExists(user.id, objV1.objId, objV1.version)).withContext('initially, there is only first version of an object').toBeTruthy();
+    // 	const diffBytes = utf8.pack(JSON.stringify(diffVer.diff));
+    // 	// upload object's next version
+    // 	const opts = copy(fstReqOpts);
+    // 	opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd(
+    // 		diffVer.objId,
+    // 		{ ver: diffVer.version, diff: diffBytes.length, header: diffVer.header.length, segs: diffVer.segs.length }));
+    // 	const rep = await doBinaryRequest<api.ReplyToPut>(opts, [ diffBytes, diffVer.header, diffVer.segs ]);
+    // 	expect(rep.status).withContext('status for successful writing of segments bytes').toBe(api.SC.okPut);
+    // 	expect(rep.data.transactionId).toBeUndefined();
+    // 	expect(await storageServer.currentObjExists(user.id, diffVer.objId, diffVer.version, diffVer)).withContext('second version of object is present on the server').toBeTruthy();
+    // });
+    (0, async_jasmine_1.itAsync)(`writes object in several requests`, async () => {
+        expect(await storageServer.currentObjExists(user.id, objV1.objId, objV1.version)).withContext('initially, there is only first version of an object').toBeTruthy();
+        const diffBytes = buffer_utils_1.utf8.pack(JSON.stringify(diffVer.diff));
+        // first request, to start transmission
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.firstPutReqUrlEnd(diffVer.objId, { ver: diffVer.version, diff: diffBytes.length, header: diffVer.header.length }));
+        let rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [diffBytes, diffVer.header]);
+        expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+        expect(typeof rep.data.transactionId).toBe('string');
+        let transactionId = rep.data.transactionId;
+        expect(await storageServer.transactionExists(user.id, diffVer.objId, transactionId)).withContext(`transaction should be open, cause not all bytes have been sent in the first request`).toBeTruthy();
+        expect(await storageServer.currentObjExists(user.id, diffVer.objId, diffVer.version)).withContext('upload is not complete, as transaction is not closed').toBeFalsy();
+        // following requests
+        let ofs = 0;
+        for (let [isNew, dvOfs, len] of diffVer.diff.sections) {
+            if (isNew === 0) {
+                ofs += len;
+                continue;
+            }
+            const last = ((dvOfs + len) >= diffVer.segs.length);
+            const delta = 256;
+            for (let ofsInSection = 0; ofsInSection < len; ofsInSection += delta) {
+                const chunk = diffVer.segs.subarray(dvOfs, dvOfs + Math.min(delta, len - ofsInSection));
+                if (last && ((ofsInSection + delta) >= len)) {
+                    opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd(diffVer.objId, { trans: transactionId, ofs, last: true }));
+                    const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                    expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+                    expect(rep.data.transactionId).toBeUndefined();
+                }
+                else {
+                    opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentObj.secondPutReqUrlEnd(diffVer.objId, { trans: transactionId, ofs }));
+                    const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                    expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentObj.SC.okPut);
+                    expect(rep.data.transactionId).toBe(transactionId);
+                }
+                dvOfs += chunk.length;
+                ofs += chunk.length;
+            }
+        }
+        expect(await storageServer.currentObjExists(user.id, diffVer.objId, diffVer.version, diffVer)).withContext('diff version of object is present on the server').toBeTruthy();
+        expect(await storageServer.transactionExists(user.id, diffVer.objId, transactionId)).toBeFalsy();
+    });
+});
+Object.freeze(exports);

package/build/tests/protocols/3nstorage/owner/specs/put-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/put-current-root.js

@@ -0,0 +1,274 @@
+"use strict";
+/*
+ Copyright (C) 2017, 2019, 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 buffer_utils_1 = require("../../../../../lib-common/buffer-utils");
+const url_1 = require("url");
+const json_copy_1 = require("../../../../libs-for-tests/json-copy");
+exports.specs = [];
+const description = `Request to save root object`;
+const objV1 = {
+    objId: 'aaaa',
+    version: 1,
+    header: (0, random_node_1.bytesSync)(100),
+    segs: (0, random_node_1.bytesSync)(2345)
+};
+const objV2 = {
+    objId: objV1.objId,
+    version: objV1.version + 1,
+    header: (0, random_node_1.bytesSync)(110),
+    segs: (0, random_node_1.bytesSync)(6543)
+};
+let fstReqOpts;
+let sndReqOpts;
+let storageServer;
+let user;
+let sessionId;
+async function setupSession(setup) {
+    storageServer = setup().storageServer;
+    user = setup().user;
+    await storageServer.restartAndClearStorageFor(user.id);
+    sessionId = await (0, test_utils_1.startSession)(user);
+    fstReqOpts = {
+        url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({ ver: 1, header: objV1.header.length })),
+        method: 'PUT',
+        responseType: 'json',
+        sessionId
+    };
+    sndReqOpts = {
+        url: (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.secondPutReqUrlEnd({ trans: 'some-trans', ofs: 0 })),
+        method: 'PUT',
+        responseType: 'json',
+        sessionId
+    };
+}
+const fuzzingSpec = { description };
+exports.specs.push(fuzzingSpec);
+fuzzingSpec.definition = (setup) => (() => {
+    let maxChunkSize;
+    (0, async_jasmine_1.beforeEachAsync)(async () => {
+        await setupSession(setup);
+        const params = await (0, _3nstorage_1.getSessionParams)(user.storageOwnerUrl, sessionId);
+        maxChunkSize = params.maxChunkSize;
+    });
+    (0, async_jasmine_1.itAsync)('fails for incorrect transaction, in secondary put', async () => {
+        const repToFstReq = await (0, xhr_utils_1.doBinaryRequest)(fstReqOpts, objV1.header);
+        expect(repToFstReq.status).toBe(owner_1.currentRootObj.SC.okPut);
+        const trans = repToFstReq.data.transactionId + ' - unknown';
+        const opts = (0, json_copy_1.copy)(sndReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.secondPutReqUrlEnd({ trans, ofs: 0 }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, objV1.segs);
+        expect(rep.status).withContext('status for unknown transaction').toBe(owner_1.currentRootObj.SC.unknownTransaction);
+    });
+    (0, async_jasmine_1.itAsync)('fails write for incorrect version', async () => {
+        await (0, _3nstorage_1.saveObj)(user.storageOwnerUrl, sessionId, null, objV1.version, objV1);
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({ ver: objV1.version + 5, header: objV1.header.length }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+        expect(rep.status).toBe(owner_1.currentRootObj.SC.mismatchedObjVer);
+        expect(typeof rep.data).toBe('object');
+        expect(rep.data.current_version).toBe(objV1.version);
+    });
+    (0, async_jasmine_1.itAsync)('will not accept bad type', async () => {
+        await (0, requests_1.expectNonAcceptanceOfBadType)(fstReqOpts, 'application/octet-stream', objV1.segs);
+        await (0, requests_1.expectNonAcceptanceOfBadType)(sndReqOpts, 'application/octet-stream', objV1.segs);
+    });
+    (0, async_jasmine_1.itAsync)('will not work outside of a valid session', async () => {
+        await (0, requests_1.expectNonAcceptanceOfBadSessionId)(fstReqOpts);
+        await (0, requests_1.expectNonAcceptanceOfBadSessionId)(sndReqOpts);
+    });
+    (0, async_jasmine_1.itAsync)('first request is limited by session parameter', async () => {
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({ ver: objV1.version, header: 100, last: true }));
+        await (0, requests_1.expectNonAcceptanceOfLongBody)(opts, 'application/octet-stream', maxChunkSize + 100);
+    });
+    (0, async_jasmine_1.itAsync)('second request is limited by session parameter', async () => {
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({ ver: objV1.version, header: objV1.header.length }));
+        const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, objV1.header);
+        const trans = rep.data.transactionId;
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.secondPutReqUrlEnd({ trans, ofs: 0, last: true }));
+        await (0, requests_1.expectNonAcceptanceOfLongBody)(opts, 'application/octet-stream', maxChunkSize + 100);
+    });
+});
+const specsForNonDiffSending = {
+    description: `${description}, non-diff version,`
+};
+exports.specs.push(specsForNonDiffSending);
+specsForNonDiffSending.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeEachAsync)(() => setupSession(setup));
+    (0, async_jasmine_1.itAsync)(`writes whole object in one request`, async () => {
+        expect(await storageServer.currentRootObjExists(user.id)).withContext('initially, there is no object').toBeFalsy();
+        // create object
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({
+            ver: objV1.version, header: objV1.header.length, last: true
+        }));
+        let rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+        expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentRootObj.SC.okPut);
+        expect(rep.data.transactionId).toBeUndefined();
+        expect(await storageServer.currentRootObjExists(user.id, objV1.version, objV1)).withContext('first version of object is present on the server').toBeTruthy();
+        // upload object's next version
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({
+            ver: objV2.version, header: objV2.header.length, last: true
+        }));
+        rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV2.header, objV2.segs]);
+        expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentRootObj.SC.okPut);
+        expect(rep.data.transactionId).toBeUndefined();
+        expect(await storageServer.currentRootObjExists(user.id, objV2.version, objV2)).withContext('second version of object is present on the server').toBeTruthy();
+        expect(await storageServer.rootTransactionExists(user.id)).toBeFalsy();
+        // returns current version, when trying to upload incorrect version,
+        // like uploading existing version, or smaller
+        const errRep = await (0, xhr_utils_1.doBinaryRequest)(opts, [objV2.header, objV2.segs]);
+        expect(errRep.status).withContext('status for mismatched upload version').toBe(owner_1.currentRootObj.SC.mismatchedObjVer);
+        expect(errRep.data.current_version).withContext('current object version on server').toBe(objV2.version);
+    });
+    (0, async_jasmine_1.itAsync)(`writes object in several requests`, async () => {
+        expect(await storageServer.currentRootObjExists(user.id)).withContext('initially, there is no object').toBeFalsy();
+        // first request, to start transmission
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({
+            ver: objV1.version, header: objV1.header.length
+        }));
+        let rep = await (0, xhr_utils_1.doBinaryRequest)(opts, objV1.header);
+        expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentRootObj.SC.okPut);
+        expect(typeof rep.data.transactionId).toBe('string');
+        let transactionId = rep.data.transactionId;
+        expect(await storageServer.rootTransactionExists(user.id, transactionId)).withContext(`transaction should be open, cause not all bytes have been sent in the first request`).toBeTruthy();
+        expect(await storageServer.currentRootObjExists(user.id, objV1.version)).withContext('upload is not complete, as transaction is not closed').toBeFalsy();
+        // following requests
+        for (let offset = 0; offset < objV1.segs.length; offset += 512) {
+            const last = ((offset + 512) >= objV1.segs.length);
+            if (last) {
+                opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.secondPutReqUrlEnd({ trans: transactionId, ofs: offset, last: true }));
+                const chunk = objV1.segs.subarray(offset, offset + 512);
+                const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentRootObj.SC.okPut);
+                expect(rep.data.transactionId).toBeUndefined();
+            }
+            else {
+                opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.secondPutReqUrlEnd({ trans: transactionId, ofs: offset }));
+                const chunk = objV1.segs.subarray(offset, offset + 512);
+                const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentRootObj.SC.okPut);
+                expect(rep.data.transactionId).toBe(transactionId);
+            }
+        }
+        expect(await storageServer.currentRootObjExists(user.id, objV1.version, objV1)).withContext('first version of object is present on the server').toBeTruthy();
+        expect(await storageServer.rootTransactionExists(user.id)).toBeFalsy();
+    });
+});
+const diffVer = {
+    objId: objV1.objId,
+    version: objV1.version + 1,
+    header: (0, random_node_1.bytesSync)(111),
+    segs: (0, random_node_1.bytesSync)(1000),
+    diff: {
+        baseVersion: 1,
+        segsSize: 1200,
+        sections: [
+            [0, 25, 100],
+            [1, 0, 300],
+            [0, 125, 100],
+            [1, 300, 700]
+        ]
+    }
+};
+const specsForDiffTransaction = {
+    description: `${description}, diff version,`
+};
+exports.specs.push(specsForDiffTransaction);
+specsForDiffTransaction.definition = (setup) => (() => {
+    (0, async_jasmine_1.beforeEachAsync)(async () => {
+        await setupSession(setup);
+        // upload first object version
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({
+            ver: objV1.version, header: objV1.header.length, last: true
+        }));
+        await (0, xhr_utils_1.doBinaryRequest)(opts, [objV1.header, objV1.segs]);
+    });
+    // XXX can't write general diff-ed object in one request.
+    // fitAsync(`writes whole object in one request`, async () => {
+    // 	expect(await storageServer.currentRootObjExists(user.id, objV1.version)).withContext('initially, there is only first version of an object').toBeTruthy();
+    // 	const diffBytes = utf8.pack(JSON.stringify(diffVer.diff));
+    // 	// upload object's next version
+    // 	const opts = copy(fstReqOpts);
+    // 	opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd(
+    // 		{ ver: diffVer.version, diff: diffBytes.length, header: diffVer.header.length, segs: diffVer.segs.length }));
+    // 	const rep = await doBinaryRequest<api.ReplyToPut>(opts, [ diffBytes, diffVer.header, diffVer.segs ]);
+    // 	expect(rep.status).withContext('status for successful writing of segments bytes').toBe(api.SC.okPut);
+    // 	expect(rep.data.transactionId).toBeUndefined();
+    // 	expect(await storageServer.currentRootObjExists(user.id, diffVer.version, diffVer)).withContext('second version of object is present on the server').toBeTruthy();
+    // });
+    (0, async_jasmine_1.itAsync)(`writes object in several requests`, async () => {
+        expect(await storageServer.currentRootObjExists(user.id, objV1.version)).withContext('initially, there is only first version of an object').toBeTruthy();
+        const diffBytes = buffer_utils_1.utf8.pack(JSON.stringify(diffVer.diff));
+        // first request, to start transmission
+        const opts = (0, json_copy_1.copy)(fstReqOpts);
+        opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.firstPutReqUrlEnd({
+            ver: diffVer.version, diff: diffBytes.length,
+            header: diffVer.header.length
+        }));
+        let rep = await (0, xhr_utils_1.doBinaryRequest)(opts, [diffBytes, diffVer.header]);
+        expect(rep.status).toBe(owner_1.currentRootObj.SC.okPut, 'status for successful writing of segments bytes');
+        expect(typeof rep.data.transactionId).toBe('string');
+        let transactionId = rep.data.transactionId;
+        expect(await storageServer.rootTransactionExists(user.id, transactionId)).withContext(`transaction should be open, cause not all bytes have been sent in the first request`).toBeTruthy();
+        expect(await storageServer.currentRootObjExists(user.id, diffVer.version)).withContext('upload is not complete, as transaction is not closed').toBeFalsy();
+        // following requests
+        let ofs = 0;
+        for (let [isNew, dvOfs, len] of diffVer.diff.sections) {
+            if (isNew === 0) {
+                ofs += len;
+                continue;
+            }
+            const last = ((dvOfs + len) >= diffVer.segs.length);
+            const delta = 256;
+            for (let ofsInSection = 0; ofsInSection < len; ofsInSection += delta) {
+                const chunk = diffVer.segs.subarray(dvOfs, dvOfs + Math.min(delta, len - ofsInSection));
+                if (last && ((ofsInSection + delta) >= len)) {
+                    opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.secondPutReqUrlEnd({
+                        trans: transactionId, ofs, last: true
+                    }));
+                    const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                    expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentRootObj.SC.okPut);
+                    expect(rep.data.transactionId).toBeUndefined();
+                }
+                else {
+                    opts.url = (0, url_1.resolve)(user.storageOwnerUrl, owner_1.currentRootObj.secondPutReqUrlEnd({ trans: transactionId, ofs }));
+                    const rep = await (0, xhr_utils_1.doBinaryRequest)(opts, chunk);
+                    expect(rep.status).withContext('status for successful writing of segments bytes').toBe(owner_1.currentRootObj.SC.okPut);
+                    expect(rep.data.transactionId).toBe(transactionId);
+                }
+                dvOfs += chunk.length;
+                ofs += chunk.length;
+            }
+        }
+        expect(await storageServer.currentRootObjExists(user.id, diffVer.version, diffVer)).withContext('diff version of object is present on the server').toBeTruthy();
+        expect(await storageServer.rootTransactionExists(user.id)).toBeFalsy();
+    });
+});
+Object.freeze(exports);

package/build/tests/protocols/3nstorage/owner/specs/trans-cancel-root.d.ts

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