spec-3nweb-server 1.8.4 → 1.8.6

package/ts-code/tests/protocols/3nstorage/owner/specs/put-current-root.ts

@@ -0,0 +1,329 @@
+/*
+ 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/>.
+*/
+
+import { startSession, SpecDescribe, TestSetup, User, StorageComponent } from '../test-utils';
+import { currentRootObj as api } from '../../../../../lib-common/service-api/3nstorage/owner';
+import { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { RequestOpts, doBinaryRequest } from '../../../../libs-for-tests/xhr-utils';
+import { Obj, getSessionParams, saveObj } from '../../../../libs-for-tests/3nstorage';
+import { expectNonAcceptanceOfBadSessionId, expectNonAcceptanceOfBadType, expectNonAcceptanceOfLongBody } from '../../../../shared-checks/requests';
+import { bytesSync as randomBytes } from '../../../../../lib-common/random-node';
+import { utf8 } from '../../../../../lib-common/buffer-utils';
+import { resolve as resolveUrl } from 'url';
+import { copy } from '../../../../libs-for-tests/json-copy';
+
+export const specs: SpecDescribe[] = [];
+
+const description = `Request to save root object`;
+
+const objV1: Obj = {
+	objId: 'aaaa',
+	version: 1,
+	header: randomBytes(100),
+	segs: randomBytes(2345)
+};
+const objV2: Obj = {
+	objId: objV1.objId,
+	version: objV1.version + 1,
+	header: randomBytes(110),
+	segs: randomBytes(6543)
+};
+
+let fstReqOpts: RequestOpts;
+let sndReqOpts: RequestOpts;
+let storageServer: StorageComponent;
+let user: User;
+let sessionId: string;
+
+async function setupSession(setup: () => TestSetup): Promise<void> {
+	storageServer = setup().storageServer;
+	user = setup().user;
+	await storageServer.restartAndClearStorageFor(user.id);
+	sessionId = await startSession(user);
+	fstReqOpts = {
+		url: resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd(
+			{ ver: 1, header: objV1.header.length })),
+		method: 'PUT',
+		responseType: 'json',
+		sessionId
+	};
+	sndReqOpts = {
+		url: resolveUrl(user.storageOwnerUrl, api.secondPutReqUrlEnd(
+			{ trans: 'some-trans', ofs: 0 })),
+		method: 'PUT',
+		responseType: 'json',
+		sessionId
+	};
+}
+
+const fuzzingSpec: SpecDescribe = { description };
+specs.push(fuzzingSpec);
+fuzzingSpec.definition = (setup: () => TestSetup) => (() => {
+	
+	let maxChunkSize: number;
+
+	beforeEachAsync(async () => {
+		await setupSession(setup);
+		const params = await getSessionParams(user.storageOwnerUrl, sessionId);
+		maxChunkSize = params.maxChunkSize;
+	});
+
+	itAsync('fails for incorrect transaction, in secondary put', async () => {
+		const repToFstReq = await doBinaryRequest<api.ReplyToPut>(
+			fstReqOpts, objV1.header);
+		expect(repToFstReq.status).toBe(api.SC.okPut);
+		const trans = repToFstReq.data.transactionId + ' - unknown';
+		const opts = copy(sndReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.secondPutReqUrlEnd(
+			{ trans, ofs: 0 }));
+		const rep = await doBinaryRequest<any>(opts, objV1.segs);
+		expect(rep.status).withContext('status for unknown transaction').toBe(api.SC.unknownTransaction);
+	});
+
+	itAsync('fails write for incorrect version', async () => {
+		await saveObj(
+			user.storageOwnerUrl, sessionId, null, objV1.version, objV1);
+		const opts = copy(fstReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd(
+			{ ver: objV1.version + 5, header: objV1.header.length }));
+		const rep = await doBinaryRequest<api.MismatchedObjVerReply>(
+			opts, [ objV1.header, objV1.segs ]);
+		expect(rep.status).toBe(api.SC.mismatchedObjVer);
+		expect(typeof rep.data).toBe('object');
+		expect(rep.data.current_version).toBe(objV1.version);
+	});
+
+	itAsync('will not accept bad type', async () => {
+		await expectNonAcceptanceOfBadType(fstReqOpts, 'application/octet-stream', objV1.segs);
+		await expectNonAcceptanceOfBadType(sndReqOpts, 'application/octet-stream', objV1.segs);
+	});
+
+	itAsync('will not work outside of a valid session', async () => {
+		await expectNonAcceptanceOfBadSessionId(fstReqOpts);
+		await expectNonAcceptanceOfBadSessionId(sndReqOpts);
+	});
+
+	itAsync('first request is limited by session parameter', async () => {
+		const opts = copy(fstReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd(
+			{ ver: objV1.version, header: 100, last: true }));
+		await expectNonAcceptanceOfLongBody(opts, 'application/octet-stream',
+			maxChunkSize+100);
+	});
+
+	itAsync('second request is limited by session parameter', async () => {
+		const opts = copy(fstReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd(
+			{ ver: objV1.version, header: objV1.header.length }));
+		const rep = await doBinaryRequest<api.ReplyToPut>(opts, objV1.header);
+		const trans = rep.data.transactionId!;
+		opts.url = resolveUrl(user.storageOwnerUrl, api.secondPutReqUrlEnd(
+			{ trans, ofs: 0, last: true }));
+		await expectNonAcceptanceOfLongBody(opts, 'application/octet-stream',
+			maxChunkSize+100);
+	});
+
+});
+
+const specsForNonDiffSending: SpecDescribe = {
+	description: `${description}, non-diff version,`
+};
+specs.push(specsForNonDiffSending);
+specsForNonDiffSending.definition = (setup: () => TestSetup) => (() => {
+	
+	beforeEachAsync(() => setupSession(setup));
+
+	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 = copy(fstReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd({
+			ver: objV1.version, header: objV1.header.length, last: true
+		}));
+		let rep = await doBinaryRequest<api.ReplyToPut>(
+			opts, [ objV1.header, objV1.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, objV1.version, objV1)).withContext('first version of object is present on the server').toBeTruthy();
+
+		// upload object's next version
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd({
+			ver: objV2.version, header: objV2.header.length, last: true
+		}));
+		rep = await doBinaryRequest<api.ReplyToPut>(
+			opts, [ objV2.header, objV2.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, 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 doBinaryRequest<api.MismatchedObjVerReply>(opts, [ objV2.header, objV2.segs ]);
+		expect(errRep.status).withContext('status for mismatched upload version').toBe(api.SC.mismatchedObjVer);
+		expect(errRep.data.current_version).withContext('current object version on server').toBe(objV2.version);
+
+	});
+
+	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 = copy(fstReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd({
+			ver: objV1.version, header: objV1.header.length
+		}));
+		let rep = await doBinaryRequest<api.ReplyToPut>(opts, objV1.header);
+		expect(rep.status).withContext('status for successful writing of segments bytes').toBe(api.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 = resolveUrl(user.storageOwnerUrl, api.secondPutReqUrlEnd(
+					{ trans: transactionId, ofs: offset, last: true }));
+				const chunk = objV1.segs.subarray(offset, offset + 512);
+				const rep = await doBinaryRequest<api.ReplyToPut>(opts, chunk);
+				expect(rep.status).withContext('status for successful writing of segments bytes').toBe(api.SC.okPut);
+				expect(rep.data.transactionId).toBeUndefined();
+			} else {
+				opts.url = resolveUrl(user.storageOwnerUrl, api.secondPutReqUrlEnd(
+					{ trans: transactionId, ofs: offset }));
+				const chunk = objV1.segs.subarray(offset, offset + 512);
+				const rep = await doBinaryRequest<api.ReplyToPut>(opts, chunk);
+				expect(rep.status).withContext('status for successful writing of segments bytes').toBe(api.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: Obj = {
+	objId: objV1.objId,
+	version: objV1.version + 1,
+	header: randomBytes(111),
+	segs: randomBytes(1000),
+	diff: {
+		baseVersion: 1,
+		segsSize: 1200,
+		sections: [
+			[ 0, 25, 100 ],
+			[ 1, 0, 300 ],
+			[ 0, 125, 100 ],
+			[ 1, 300, 700 ] ]
+	}
+};
+
+const specsForDiffTransaction: SpecDescribe = {
+	description: `${description}, diff version,`
+};
+specs.push(specsForDiffTransaction);
+specsForDiffTransaction.definition = (setup: () => TestSetup) => (() => {
+	
+	beforeEachAsync(async () => {
+		await setupSession(setup);
+		// upload first object version
+		const opts = copy(fstReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd({
+			ver: objV1.version, header: objV1.header.length, last: true
+		}));
+		await doBinaryRequest<api.ReplyToPut>(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();
+
+	// });
+
+	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 = utf8.pack(JSON.stringify(diffVer.diff));
+
+		// first request, to start transmission
+		const opts = copy(fstReqOpts);
+		opts.url = resolveUrl(user.storageOwnerUrl, api.firstPutReqUrlEnd({
+			ver: diffVer.version, diff: diffBytes.length,
+			header: diffVer.header.length
+		}));
+		let rep = await doBinaryRequest<api.ReplyToPut>(opts, [ diffBytes, diffVer.header ]);
+		expect(rep.status).toBe(api.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 = resolveUrl(user.storageOwnerUrl,
+						api.secondPutReqUrlEnd({
+							trans: transactionId, ofs, last: true
+						}));
+					const rep = await doBinaryRequest<api.ReplyToPut>(opts, chunk);
+					expect(rep.status).withContext('status for successful writing of segments bytes').toBe(api.SC.okPut);
+					expect(rep.data.transactionId).toBeUndefined();
+				} else {
+					opts.url = resolveUrl(user.storageOwnerUrl,
+						api.secondPutReqUrlEnd({ trans: transactionId, ofs }));
+					const rep = await doBinaryRequest<api.ReplyToPut>(opts, chunk);
+					expect(rep.status).withContext('status for successful writing of segments bytes').toBe(api.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/ts-code/tests/protocols/3nstorage/owner/specs/trans-cancel-root.ts

@@ -0,0 +1,86 @@
+/*
+ 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/>.
+*/
+
+import { startSession, SpecDescribe, TestSetup, User, StorageComponent } from '../test-utils';
+import { cancelRootTransaction as api, currentRootObj as rootApi } from '../../../../../lib-common/service-api/3nstorage/owner';
+import { beforeAllAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { RequestOpts, doBodylessRequest, doBinaryRequest } from '../../../../libs-for-tests/xhr-utils';
+import { Obj }	from '../../../../libs-for-tests/3nstorage';
+import { expectNonAcceptanceOfBadSessionId, expectNonAcceptanceOfNonEmptyBody } from '../../../../shared-checks/requests';
+import { bytesSync as randomBytes } from '../../../../../lib-common/random-node';
+import { resolve as resolveUrl } from 'url';
+
+export const specs: SpecDescribe = {
+	description: 'Request to cancel root object transaction'
+};
+
+const obj: Obj = {
+	objId: (null as any),
+	version: 1,
+	header: randomBytes(100),
+	segs: randomBytes(573)
+};
+
+specs.definition = (setup: () => TestSetup) => (() => {
+	
+	let reqOpts: RequestOpts
+	let storageServer: StorageComponent;
+	let user: User;
+	let transactionId: string;
+
+	beforeAllAsync(async () => {
+		storageServer = setup().storageServer;
+		user = setup().user;
+		await storageServer.restartAndClearStorageFor(user.id);
+		const sessionId = await startSession(user);
+		const fstReqOpts: RequestOpts = {
+			url: resolveUrl(user.storageOwnerUrl, rootApi.firstPutReqUrlEnd({
+				ver: 1, header: obj.header.length
+			})),
+			method: 'PUT',
+			sessionId
+		};
+		const fstRep = await doBinaryRequest<rootApi.ReplyToPut>(
+			fstReqOpts, obj.header);
+		transactionId = fstRep.data.transactionId!;
+		reqOpts = {
+			url: resolveUrl(user.storageOwnerUrl, api.getReqUrlEnd(transactionId)),
+			method: 'POST',
+			sessionId
+		};
+	});
+	
+	itAsync('cancels root object transaction', async () => {
+		expect(await storageServer.currentRootObjExists(user.id)).withContext('initially, there is no root object').toBeFalsy();
+		expect(await storageServer.rootTransactionExists(user.id)).withContext('initially, there is a started transaction').toBeTruthy();
+		
+		const rep = await doBodylessRequest<void>(reqOpts);
+		expect(rep.status).withContext('status for normal transaction cancelation').toBe(api.SC.ok);
+		expect(await storageServer.rootTransactionExists(user.id)).withContext('transaction should not exist, as it has been cancelled.').toBeFalsy();
+		expect(await storageServer.currentRootObjExists(user.id, 1, obj)).withContext('object is not created, cause transaction has been cancelled').toBeFalsy();
+
+		// XXX split out fuzzing requests
+		
+		await expectNonAcceptanceOfNonEmptyBody(reqOpts);
+		
+		await expectNonAcceptanceOfBadSessionId(reqOpts);
+	
+	});
+
+	// XXX add cancelation with unknown transaction id (repeat request)
+	
+});

package/ts-code/tests/protocols/3nstorage/owner/specs/trans-cancel.ts

@@ -0,0 +1,86 @@
+/*
+ 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/>.
+*/
+
+import { startSession, SpecDescribe, TestSetup, User, StorageComponent } from '../test-utils';
+import { cancelTransaction as api, currentObj as objApi } from '../../../../../lib-common/service-api/3nstorage/owner';
+import { beforeAllAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { RequestOpts, doBodylessRequest, doBinaryRequest } from '../../../../libs-for-tests/xhr-utils';
+import { Obj }	from '../../../../libs-for-tests/3nstorage';
+import { expectNonAcceptanceOfBadSessionId, expectNonAcceptanceOfNonEmptyBody } from '../../../../shared-checks/requests';
+import { bytesSync as randomBytes } from '../../../../../lib-common/random-node';
+import { resolve as resolveUrl } from 'url';
+
+export const specs: SpecDescribe = {
+	description: 'Request to cancel non-root object transaction'
+};
+
+const obj: Obj = {
+	objId: 'aaaa',
+	version: 1,
+	header: randomBytes(100),
+	segs: randomBytes(573)
+};
+
+specs.definition = (setup: () => TestSetup) => (() => {
+	
+	let reqOpts: RequestOpts
+	let storageServer: StorageComponent;
+	let user: User;
+	let transactionId: string;
+
+	beforeAllAsync(async () => {
+		storageServer = setup().storageServer;
+		user = setup().user;
+		await storageServer.restartAndClearStorageFor(user.id);
+		const sessionId = await startSession(user);
+		const fstReqOpts: RequestOpts = {
+			url: resolveUrl(user.storageOwnerUrl, objApi.firstPutReqUrlEnd(
+				obj.objId, { ver: 1, header: obj.header.length })),
+			method: 'PUT',
+			sessionId
+		};
+		const fstRep = await doBinaryRequest<objApi.ReplyToPut>(
+			fstReqOpts, obj.header);
+		transactionId = fstRep.data.transactionId!;
+		reqOpts = {
+			url: resolveUrl(user.storageOwnerUrl, api.getReqUrlEnd(obj.objId, transactionId)),
+			method: 'POST',
+			sessionId: sessionId
+		};
+	});
+	
+	itAsync('cancels object transaction', async () => {
+		expect(await storageServer.currentObjExists(user.id, obj.objId)).withContext('initially, there is no object').toBeFalsy();
+		expect(await storageServer.transactionExists(user.id, obj.objId)).withContext('initially, there is a started transaction').toBeTruthy();
+		
+		// normal reply
+		const rep = await doBodylessRequest<void>(reqOpts);
+		expect(rep.status).withContext('status for normal transaction completion').toBe(api.SC.ok);
+		expect(await storageServer.transactionExists(user.id, obj.objId)).withContext('transaction should not be present, as it has been completed').toBeFalsy();
+		expect(await storageServer.currentObjExists(user.id, obj.objId, 1, obj)).withContext('object is not created, cause transaction has been cancelled').toBeFalsy();
+		
+		// XXX split out fuzzing requests
+
+		await expectNonAcceptanceOfNonEmptyBody(reqOpts);
+		
+		await expectNonAcceptanceOfBadSessionId(reqOpts);
+		
+	});
+
+	// XXX add cancelation with unknown object id, and unknown transaction id
+	
+});

package/ts-code/tests/protocols/3nstorage/owner/test-utils.ts

@@ -0,0 +1,72 @@
+/*
+ Copyright (C) 2016, 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/>.
+*/
+
+import { User, doMailerIdLogin } from '../../../libs-for-tests/mailerid';
+import { resolve as resolveUrl } from 'url';
+import * as api from '../../../../lib-common/service-api/3nstorage/owner';
+import { StorageComponent } from '../../../libs-for-tests/server-components/3nstorage';
+import { GenericSpecDescribe } from '../../../libs-for-tests/spec-assembly';
+import { doBodylessRequest } from '../../../libs-for-tests/xhr-utils';
+import { assert } from '../../../libs-for-tests/assert';
+
+export { User } from '../../../libs-for-tests/mailerid';
+export { StorageComponent } from '../../../libs-for-tests/server-components/3nstorage';
+
+export interface TestSetup {
+	user: User;
+	storageServer: StorageComponent;
+}
+
+export type SpecDescribe = GenericSpecDescribe<TestSetup>;
+
+export async function startSession(user: User): Promise<string> {
+	return await doMailerIdLogin(
+		resolveUrl(user.storageOwnerUrl, api.midLogin.URL_PART),
+		user
+	);
+}
+
+export async function getObjStatus(
+	user: User, objId: string|null, sessionId: string
+): Promise<api.ObjStatus> {
+	const rep = await doBodylessRequest<api.ObjStatus>({
+		url: resolveUrl(user.storageOwnerUrl, (objId ?
+			api.objStatus.getReqUrlEnd(objId) : api.rootStatus.getReqUrlEnd())
+		),
+		method: 'GET',
+		sessionId,
+		responseType: 'json'
+	});
+	assert(rep.status === api.objStatus.SC.ok, `Unexpected status ${rep.status} with data ${rep.data}, when listing archived versions of object ${objId}`);
+	return rep.data;
+}
+
+export async function archiveObjVer(
+	user: User, objId: string|null, version: number, sessionId: string
+): Promise<void> {
+	const rep = await doBodylessRequest<void>({
+		url: resolveUrl(user.storageOwnerUrl, (objId ?
+			api.archiveObj.postAndDelReqUrlEnd(objId, version) :
+			api.archiveRoot.postAndDelReqUrlEnd(version))),
+		method: 'POST',
+		sessionId
+	});
+	assert(rep.status === api.archiveObj.SC.okPost, `Unexpected status ${rep.status} with data ${rep.data}, when archiving version ${version} of object ${objId}`);
+}
+
+
+Object.freeze(exports);