spec-3nweb-server 1.8.4 → 1.8.6

package/ts-code/tests/libs-for-tests/spec-assembly.ts

@@ -0,0 +1,60 @@
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { join as joinPaths } from 'path';
+import { readdirSync } from 'fs';
+
+export interface GenericSpecDescribe<TSetup> {
+	description: string;
+	definition?: (setup: () => TSetup) => (() => void);
+	focused?: boolean;
+}
+
+type ExportedSpecs<TSetup> =
+	GenericSpecDescribe<TSetup> | GenericSpecDescribe<TSetup>[]
+
+function setupSpecs<TSetup>(specs: GenericSpecDescribe<TSetup>,
+		setup: () => TSetup): void {
+	if (!specs.definition) { return; }
+	if (specs.focused) {
+		fdescribe(specs.description, specs.definition(setup));
+	} else {
+		describe(specs.description, specs.definition(setup));			
+	}
+}
+
+export function addSpecsFrom<TSetup>(specsFolder: string,
+		setup: () => TSetup): void {
+	for (let fName of readdirSync(specsFolder)) {
+		if (!fName.endsWith('.js')) { continue; }
+		let modPath = joinPaths(specsFolder, fName);
+		let specs: ExportedSpecs<TSetup> = require(modPath).specs;
+		if (!specs) {
+			console.error(`Module ${fName} is not exposing specs objects with tests`);
+			continue;
+		}
+		if (Array.isArray(specs)) {
+			for (let s of specs) {
+				setupSpecs(s, setup);
+			}
+		} else {
+			setupSpecs(specs, setup);
+		}
+	}
+}
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/ws-utils.ts

@@ -0,0 +1,61 @@
+/*
+ Copyright (C) 2017, 2019 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import * as WebSocket from 'ws';
+import { IncomingMessage } from 'http';
+import { SESSION_ID_HEADER, Reply } from './xhr-utils';
+import { defer } from '../../lib-common/processes';
+import { makeConnectionException } from '../../lib-common/exceptions/http';
+import { globalAgent as agent } from 'https';
+
+export function openSocket(url: string, sessionId: string):
+		Promise<Reply<WebSocket>> {
+	if (!url.startsWith('wss://')) { throw new Error(
+		`Url protocol must be wss`); }
+	const headers: any = {};
+	headers[SESSION_ID_HEADER] = sessionId;
+	const ws = new WebSocket(url, { headers, agent });
+	const opening = defer<Reply<WebSocket>>();
+	const initOnError = err => opening.reject(makeConnectionException(
+		url, undefined,
+		`Cannot open websocket connection due to error: ${err.message}`));
+	const onNonOkReply = (req, res: IncomingMessage) => {
+		const errReply: Reply<WebSocket> = {
+			url,
+			method: 'GET',
+			status: res.statusCode!,
+			data: (undefined as any)
+		};
+		opening.resolve(errReply);
+	};
+	ws.on('error', initOnError);
+	ws.on('unexpected-response', onNonOkReply);
+	ws.once('open', () => {
+		const okReply: Reply<WebSocket> = {
+			url,
+			method: 'GET',
+			status: 200,
+			data: ws
+		};
+		opening.resolve(okReply);
+		ws.removeListener('error', initOnError);
+		ws.removeListener('unexpected-response', onNonOkReply);
+	});
+	return opening.promise;
+}
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/xhr-utils.ts

@@ -0,0 +1,179 @@
+/*
+ Copyright (C) 2015 - 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 { makeHTTPException, makeConnectionException, HTTPException }
+	from '../../lib-common/exceptions/http';
+import { BytesFIFOBuffer } from '../../lib-common/byte-streaming/common';
+
+const xhr2 = require('xhr2');
+
+export const SESSION_ID_HEADER = "X-Session-Id";
+
+export interface Reply<T> {
+	url: string;
+	method: string;
+	status: number;
+	data: T;
+	headers?: Headers;
+}
+
+export interface RequestOpts {
+	method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+	url?: string;
+	path?: string;
+	responseType?: 'json' | 'arraybuffer';
+	sessionId?: string;
+	responseHeaders?: string[];
+}
+
+export interface Headers {
+	get(name: string): string|undefined;
+}
+
+function makeHeadersInstanceFrom(xhr: XMLHttpRequest, selectHeaders: string[]):
+		Headers {
+	const m = new Map<string, string>();
+	for (const h of selectHeaders) {
+		if (typeof h !== 'string') { continue; }
+		const value = xhr.getResponseHeader(h);
+		if (typeof value !== 'string') { continue; }
+		m.set(h.toLowerCase(), value);
+	}
+	return {
+		get(name: string): string|undefined {
+			return m.get(name.toLowerCase());
+		}
+	};
+}
+
+export function request<T>(contentType: string|undefined, opts: RequestOpts):
+		{ xhr: XMLHttpRequest; promise: Promise<Reply<T>>; } {
+	const xhr: XMLHttpRequest = new xhr2();
+	const promise = new Promise<Reply<T>>((resolve, reject) => {
+		xhr.open(opts.method, opts.url!);
+		xhr.onload = () => {
+			let data = xhr.response;
+			if ((opts.responseType === 'arraybuffer') &&
+					(data instanceof ArrayBuffer)) {
+				data = new Uint8Array(data);
+			}
+			const rep: Reply<T> = {
+				url: opts.url!,
+				method: opts.method,
+				status: xhr.status,
+				data: data
+			};
+			if (Array.isArray(opts.responseHeaders)) {
+				rep.headers = makeHeadersInstanceFrom(xhr, opts.responseHeaders);
+			}
+			resolve(rep);
+		};
+		xhr.onerror = ev => reject(
+			makeConnectionException(opts.url, opts.method, 'Cannot connect', ev)
+		);
+		if (contentType) {
+			xhr.setRequestHeader('Content-Type', contentType);
+		}
+		if (opts.sessionId) {
+			xhr.setRequestHeader(SESSION_ID_HEADER, opts.sessionId);
+		}
+		if (opts.responseType) {
+			xhr.responseType = opts.responseType;
+		}
+	});
+	return { xhr, promise };
+}
+
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: application/json' and
+ * sends given json. 
+ * @param opts
+ * @param json
+ * @return a promise, resolvable to reply object
+ */
+export function doJsonRequest<T>(opts: RequestOpts, json: any):
+		Promise<Reply<T>> {
+	const req = request<T>('application/json', opts);
+	const body = ((json === undefined) ? '' : JSON.stringify(json));
+	req.xhr.send(body);
+	return req.promise;
+}
+
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: application/octet-stream'
+ * and sends given bytes.
+ * @param opts
+ * @param bytes
+ * @return a promise, resolvable to reply object
+ */
+export function doBinaryRequest<T>(opts: RequestOpts,
+		bytes: Uint8Array|Uint8Array[]): Promise<Reply<T>> {
+	const req = request<T>('application/octet-stream', opts);
+	if (Array.isArray(bytes)) {
+		const fifo = new BytesFIFOBuffer();
+		for (const arr of bytes) {
+			fifo.push(arr);
+		}
+		req.xhr.send(fifo.getBytes(undefined));
+	} else {
+		req.xhr.send(bytes);
+	}
+	return req.promise;
+}
+
+/**
+ * This assembles XMLHttpRequest with 'Content-Type: text/plain'
+ * and sends given text
+ * @param opts
+ * @param txt
+ * @return a promise, resolvable to reply object
+ */
+export function doTextRequest<T>(opts: RequestOpts, txt: string):
+		Promise<Reply<T>> {
+	const req = request<T>('text/plain', opts);
+	req.xhr.send(txt);
+	return req.promise;
+}
+
+/**
+ * This assembles XMLHttpRequest without 'Content-Type'.
+ * @param opts
+ * @return a promise, resolvable to reply object
+ */
+export function doBodylessRequest<T>(opts: RequestOpts): Promise<Reply<T>> {
+	const req = request<T>(undefined, opts);
+	req.xhr.send();
+	return req.promise;
+}
+
+/**
+ * @param rep
+ * @param errMsg
+ * @return http exception based on given reply, with an optional message
+ */
+export function makeException(rep: Reply<any>, errMsg?: string): HTTPException {
+	return makeHTTPException(rep.url, rep.method, rep.status, errMsg);
+}
+
+export function extractIntHeader(rep: Reply<any>, headerName: string): number {
+	const intHeader = parseInt(rep.headers!.get(headerName)!);
+	if (isNaN(intHeader)) { throw makeException(rep,
+		`Malformed response: header ${headerName} is missing or malformed`); }
+	return intHeader;
+}
+
+Object.freeze(exports);

package/ts-code/tests/protocols/3nstorage/owner/specs/archive-obj-ver.ts

@@ -0,0 +1,100 @@
+/*
+ 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/>.
+*/
+
+import { startSession, SpecDescribe, TestSetup, User, StorageComponent, getObjStatus } from '../test-utils';
+import { archiveObj as api } from '../../../../../lib-common/service-api/3nstorage/owner';
+import { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { RequestOpts, doBodylessRequest } from '../../../../libs-for-tests/xhr-utils';
+import { Obj, saveObj }	from '../../../../libs-for-tests/3nstorage';
+import { expectNonAcceptanceOfBadSessionId } from '../../../../shared-checks/requests';
+import { bytesSync as randomBytes } from '../../../../../lib-common/random-node';
+import { resolve as resolveUrl } from 'url';
+import { copy } from '../../../../libs-for-tests/json-copy';
+
+export const specs: SpecDescribe = {
+	description: `Request to archive object's versions`
+};
+
+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 sessionId: string;
+
+	beforeEachAsync(async () => {
+		storageServer = setup().storageServer;
+		user = setup().user;
+		await storageServer.restartAndClearStorageFor(user.id);
+		sessionId = await startSession(user);
+		reqOpts = {
+			url: resolveUrl(
+				user.storageOwnerUrl,
+				api.postAndDelReqUrlEnd(obj.objId, obj.version)),
+			method: 'POST',
+			sessionId
+		};
+	});
+
+	itAsync('will not work outside of a valid session', async () => {
+		const opts = copy(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(opts);
+	});
+
+	itAsync('fails when object does not exist', async () => {
+		const unknownObj = 'unknown-obj';
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(
+			user.storageOwnerUrl,
+			api.postAndDelReqUrlEnd(unknownObj, 42));
+		const rep = await doBodylessRequest(opts);
+		expect(rep.status).toBe(api.SC.unknownObj);
+	});
+
+	itAsync('fails when object version does not exist', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(
+			user.storageOwnerUrl,
+			api.postAndDelReqUrlEnd(obj.objId, 42));
+		opts.responseType = 'json';
+		const rep = await doBodylessRequest<api.MismatchedObjVerReply>(opts);
+		expect(rep.status).toBe(api.SC.mismatchedObjVer);
+		expect(rep.data.current_version).toBe(1);
+	});
+
+	itAsync('sets current version archived', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		let archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toBeUndefined();
+		const rep = await doBodylessRequest(reqOpts);
+		expect(rep.status).toBe(api.SC.okPost);
+		archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toContain(1);
+	});
+
+});
+
+
+Object.freeze(exports);

package/ts-code/tests/protocols/3nstorage/owner/specs/archive-root-ver.ts

@@ -0,0 +1,91 @@
+/*
+ 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/>.
+*/
+
+import { startSession, SpecDescribe, TestSetup, User, StorageComponent, getObjStatus } from '../test-utils';
+import { archiveRoot as api } from '../../../../../lib-common/service-api/3nstorage/owner';
+import { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { RequestOpts, doBodylessRequest } from '../../../../libs-for-tests/xhr-utils';
+import { Obj, saveObj }	from '../../../../libs-for-tests/3nstorage';
+import { expectNonAcceptanceOfBadSessionId } from '../../../../shared-checks/requests';
+import { bytesSync as randomBytes } from '../../../../../lib-common/random-node';
+import { resolve as resolveUrl } from 'url';
+import { copy } from '../../../../libs-for-tests/json-copy';
+
+export const specs: SpecDescribe = {
+	description: `Request to archive root's versions`
+};
+
+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 sessionId: string;
+
+	beforeEachAsync(async () => {
+		storageServer = setup().storageServer;
+		user = setup().user;
+		await storageServer.restartAndClearStorageFor(user.id);
+		sessionId = await startSession(user);
+		reqOpts = {
+			url: resolveUrl(
+				user.storageOwnerUrl,
+				api.postAndDelReqUrlEnd(obj.version)),
+			method: 'POST',
+			responseType: 'json',
+			sessionId
+		};
+	});
+
+	itAsync('will not work outside of a valid session', async () => {
+		const opts = copy(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(opts);
+	});
+
+	itAsync('fails when object version does not exist', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(
+			user.storageOwnerUrl,
+			api.postAndDelReqUrlEnd(42));
+		opts.responseType = 'json';
+		const rep = await doBodylessRequest<api.MismatchedObjVerReply>(opts);
+		expect(rep.status).toBe(api.SC.mismatchedObjVer);
+		expect(rep.data.current_version).toBe(1);
+	});
+
+	itAsync('sets current version archived', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		let archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toBeUndefined();
+		const rep = await doBodylessRequest(reqOpts);
+		expect(rep.status).toBe(api.SC.okPost);
+		archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toContain(1);
+	});
+
+});
+
+
+Object.freeze(exports);

package/ts-code/tests/protocols/3nstorage/owner/specs/delete-archive-obj-ver.ts

@@ -0,0 +1,99 @@
+/*
+ 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/>.
+*/
+
+import { startSession, SpecDescribe, TestSetup, User, StorageComponent, archiveObjVer, getObjStatus } from '../test-utils';
+import { archiveObj as api } from '../../../../../lib-common/service-api/3nstorage/owner';
+import { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { RequestOpts, doBodylessRequest } from '../../../../libs-for-tests/xhr-utils';
+import { Obj, saveObj }	from '../../../../libs-for-tests/3nstorage';
+import { expectNonAcceptanceOfBadSessionId } from '../../../../shared-checks/requests';
+import { bytesSync as randomBytes } from '../../../../../lib-common/random-node';
+import { resolve as resolveUrl } from 'url';
+import { copy } from '../../../../libs-for-tests/json-copy';
+
+export const specs: SpecDescribe = {
+	description: `Request to archive object's versions`
+};
+
+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 sessionId: string;
+
+	beforeEachAsync(async () => {
+		storageServer = setup().storageServer;
+		user = setup().user;
+		await storageServer.restartAndClearStorageFor(user.id);
+		sessionId = await startSession(user);
+		reqOpts = {
+			url: resolveUrl(
+				user.storageOwnerUrl,
+				api.postAndDelReqUrlEnd(obj.objId, obj.version)),
+			method: 'DELETE',
+			sessionId
+		};
+	});
+
+	itAsync('will not work outside of a valid session', async () => {
+		const opts = copy(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(opts);
+	});
+
+	itAsync('fails when object does not exist', async () => {
+		const unknownObj = 'unknown-obj';
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(
+			user.storageOwnerUrl,
+			api.postAndDelReqUrlEnd(unknownObj, 42));
+		const rep = await doBodylessRequest(opts);
+		expect(rep.status).toBe(api.SC.unknownObj);
+	});
+
+	itAsync('fails when object version does not exist', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(
+			user.storageOwnerUrl,
+			api.postAndDelReqUrlEnd(obj.objId, 42));
+		const rep = await doBodylessRequest(opts);
+		expect(rep.status).toBe(api.SC.unknownObjVer);
+	});
+
+	itAsync('Removes archived version', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		await archiveObjVer(user, obj.objId, 1, sessionId);
+		let archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toContain(1);
+		const rep = await doBodylessRequest(reqOpts);
+		expect(rep.status).toBe(api.SC.okDelete);
+		archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toBeUndefined();
+	});
+
+});
+
+
+Object.freeze(exports);

package/ts-code/tests/protocols/3nstorage/owner/specs/delete-archive-root-ver.ts

@@ -0,0 +1,90 @@
+/*
+ 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/>.
+*/
+
+import { startSession, SpecDescribe, TestSetup, User, StorageComponent, archiveObjVer, getObjStatus } from '../test-utils';
+import { archiveRoot as api } from '../../../../../lib-common/service-api/3nstorage/owner';
+import { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { RequestOpts, doBodylessRequest } from '../../../../libs-for-tests/xhr-utils';
+import { Obj, saveObj }	from '../../../../libs-for-tests/3nstorage';
+import { expectNonAcceptanceOfBadSessionId } from '../../../../shared-checks/requests';
+import { bytesSync as randomBytes } from '../../../../../lib-common/random-node';
+import { resolve as resolveUrl } from 'url';
+import { copy } from '../../../../libs-for-tests/json-copy';
+
+export const specs: SpecDescribe = {
+	description: `Request to archive root's versions`
+};
+
+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 sessionId: string;
+
+	beforeEachAsync(async () => {
+		storageServer = setup().storageServer;
+		user = setup().user;
+		await storageServer.restartAndClearStorageFor(user.id);
+		sessionId = await startSession(user);
+		reqOpts = {
+			url: resolveUrl(
+				user.storageOwnerUrl,
+				api.postAndDelReqUrlEnd(obj.version)),
+			method: 'DELETE',
+			responseType: 'json',
+			sessionId
+		};
+	});
+
+	itAsync('will not work outside of a valid session', async () => {
+		const opts = copy(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(opts);
+	});
+
+	itAsync('fails when object version does not exist', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(
+			user.storageOwnerUrl,
+			api.postAndDelReqUrlEnd(42));
+		const rep = await doBodylessRequest(opts);
+		expect(rep.status).toBe(api.SC.unknownObjVer);
+	});
+
+	itAsync('Removes archived version', async () => {
+		await saveObj(user.storageOwnerUrl, sessionId, obj.objId, 1, obj);
+		await archiveObjVer(user, obj.objId, 1, sessionId);
+		let archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toContain(1);
+		const rep = await doBodylessRequest(reqOpts);
+		expect(rep.status).toBe(api.SC.okDelete);
+		archived = (await getObjStatus(user, obj.objId, sessionId)).archived;
+		expect(archived).toBeUndefined();
+	});
+
+});
+
+
+Object.freeze(exports);