spec-3nweb-server 1.8.4 → 1.8.6

package/ts-code/tests/protocols/asmail/retrieval/specs/get-message-obj.ts

@@ -0,0 +1,197 @@
+/*
+ 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 { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { SpecDescribe, TestSetup, User, msg, ASMailComponent, startSession, sendMsg, Obj } from '../test-utils';
+import { resolve as resolveUrl } from 'url';
+import { msgObj as api, HTTP_HEADER, ERR_SC } from '../../../../../lib-common/service-api/asmail/retrieval';
+import { RequestOpts, Reply, doBodylessRequest } from '../../../../libs-for-tests/xhr-utils';
+import { expectNonAcceptanceOfBadSessionId } from '../../../../shared-checks/requests';
+import { copy } from '../../../../libs-for-tests/json-copy';
+import { bytesEqual } from '../../../../libs-for-tests/bytes-equal';
+
+const obj1 = msg.msgObjs[0];
+const obj2 = msg.msgObjs[1];
+
+export const specs: SpecDescribe = {
+	description: `Request to get message object`
+};
+
+function checkReplyExpectation(rep: Reply<Uint8Array>, obj: Obj,
+		headerPresent: boolean, expectedSegsBytes: Uint8Array): void {
+	// status
+	expect(rep.status).withContext('status for returned bytes').toBe(api.SC.ok);
+
+	// object's header length http header
+	const headerLen = obj.header.length;
+	if (headerPresent) {
+		expect(parseInt(rep.headers!.get(HTTP_HEADER.objHeaderLength)!)).withContext('object header size must be given in the reply header').toBe(headerLen);
+	}
+
+	// segments length header
+	expect(parseInt(rep.headers!.get(HTTP_HEADER.objSegmentsLength)!)).withContext('object segments size must be given in the reply header').toBe(obj.segs.length);
+
+	// check body
+	if (headerPresent) {
+		expect(bytesEqual(rep.data.subarray(0, headerLen), obj.header)).withContext('reply should have header bytes at the front').toBe(true);
+		expect(bytesEqual(rep.data.subarray(headerLen), expectedSegsBytes)).withContext('reply should have proper segments bytes, following header bytes').toBe(true);
+	} else {
+		expect(bytesEqual(rep.data, expectedSegsBytes)).withContext('reply should have proper segments bytes').toBe(true);
+	}
+}
+
+specs.definition = (setup: () => TestSetup) => (() => {
+	
+	let asmailServer: ASMailComponent;
+	let retrievalUrl: string;
+	let deliveryUrl: string;
+	let user1: User;
+	let reqOpts: RequestOpts
+	let msgId: string;
+
+	beforeEachAsync(async () => {
+		asmailServer = setup().asmailServer;
+		retrievalUrl = await asmailServer.getRetrievalUrl();
+		deliveryUrl = await asmailServer.getDeliveryUrl();
+		user1 = setup().user1;
+		msgId = await sendMsg(deliveryUrl, user1.id, msg);
+		const sessionId = await startSession(user1, retrievalUrl);
+		reqOpts = {
+			url: resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj1.objId,
+				{ header: true })),
+			method: 'GET',
+			responseType: 'arraybuffer',
+			sessionId,
+			responseHeaders: [ HTTP_HEADER.objHeaderLength,
+				HTTP_HEADER.objSegmentsLength ]
+		};
+	});
+
+	itAsync('fails when message does not exist', async () => {
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd('unknown-message', 'some-obj'));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		expect(rep.status).toBe(api.SC.unknownMsgOrObj);
+	});
+
+	itAsync('fails when object does not exist', async () => {
+		const unknownObj = 'unknown-obj';
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, unknownObj));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		expect(rep.status).toBe(api.SC.unknownMsgOrObj);
+	});
+
+	itAsync('will not accept bad parameters', async () => {
+		const opts = copy(reqOpts);
+		const objId = msg.msgObjs[0].objId;
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, objId,
+			{ ofs: -34 }));
+		let rep = await doBodylessRequest<Uint8Array>(opts);
+		expect(rep.status).toBe(ERR_SC.malformed);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, objId,
+			{ limit: -34 }));
+		rep = await doBodylessRequest<Uint8Array>(opts);
+		expect(rep.status).toBe(ERR_SC.malformed);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, objId,
+			{ ofs: 10, limit: 0 }));
+		rep = await doBodylessRequest<Uint8Array>(opts);
+		expect(rep.status).toBe(ERR_SC.malformed);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, objId,
+			{ header: true, ofs: 10 }));
+		rep = await doBodylessRequest<Uint8Array>(opts);
+		expect(rep.status).toBe(ERR_SC.malformed);
+	});
+
+	itAsync('returns header and all segments', async () => {
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj1.objId,
+			{ header: true }));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj1, true, obj1.segs);
+	});
+
+	itAsync('returns header without segments', async () => {
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj1.objId, { header: true, limit: 0 }));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj1, true, new Uint8Array(0));
+	});
+
+	itAsync('returns all segments without header', async () => {
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj1.objId));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj1, false, obj1.segs);
+	});
+
+	itAsync('returns chunk, when offset and limit are given', async () => {
+		const opts = copy(reqOpts);
+		// with non-overflowing limit
+		for (let offset=0; offset<=obj2.segs.length; offset+=512) {
+			const chunkLen = Math.min(512, obj2.segs.length - offset);
+			opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj2.objId,
+				{ ofs: offset, limit: chunkLen }));
+			const rep = await doBodylessRequest<Uint8Array>(opts);
+			checkReplyExpectation(rep, obj2, false, obj2.segs.subarray(offset, offset+chunkLen));
+		}
+		// with overflowing limit
+		const offset = obj2.segs.length - 100;
+		const requestedLen = 300
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj2.objId,
+			{ ofs: offset, limit: requestedLen }));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj2, false, obj2.segs.subarray(offset));
+	});
+
+	itAsync('reads segments from start, when offset is not given', async () => {
+		const opts = copy(reqOpts);
+		// with non-overflowing length
+		const chunkLen = 512;
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj2.objId,
+			{ limit: chunkLen }));
+		let rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj2, false, obj2.segs.subarray(0, chunkLen));
+		// with overflowing length
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj2.objId,
+			{ limit: obj2.segs.length+300 }));
+		rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj2, false, obj2.segs);
+	});
+
+	itAsync('reads segments to the end, when limit is not given', async () => {
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj2.objId,
+			{ ofs: 1234 }));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj2, false, obj2.segs.subarray(1234));
+	});
+
+	itAsync('no-bytes read', async () => {
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId, obj2.objId,
+			{ ofs: obj2.segs.length, limit: 500 }));
+		const rep = await doBodylessRequest<Uint8Array>(opts);
+		checkReplyExpectation(rep, obj2, false, new Uint8Array(0));
+	});
+		
+	itAsync(`requires open session`, async () => {
+		const opts = copy(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(opts);
+	});
+
+});

package/ts-code/tests/protocols/asmail/retrieval/specs/list-messages.ts

@@ -0,0 +1,110 @@
+/*
+ Copyright (C) 2016 - 2017б 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 { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { SpecDescribe, TestSetup, User, msg, startSession, sendMsg } from '../test-utils';
+import { resolve as resolveUrl } from 'url';
+import { listMsgs as api } from '../../../../../lib-common/service-api/asmail/retrieval';
+import { RequestOpts, doBodylessRequest } from '../../../../libs-for-tests/xhr-utils';
+import { expectNonAcceptanceOfBadSessionId } from '../../../../shared-checks/requests';
+import { copy } from '../../../../libs-for-tests/json-copy';
+import { msgSendingSteps } from '../../../../libs-for-tests/asmail';
+
+export const specs: SpecDescribe = {
+	description: `Request to list messages in inbox`
+};
+
+specs.definition = (setup: () => TestSetup) => (() => {
+
+	let retrievalUrl: string;
+	let deliveryUrl: string;
+	let user1: User;
+	let reqOpts: RequestOpts
+
+	beforeEachAsync(async () => {
+		retrievalUrl = await setup().asmailServer.getRetrievalUrl();
+		deliveryUrl = await setup().asmailServer.getDeliveryUrl();
+		user1 = setup().user1;
+		const sessionId = await startSession(user1, retrievalUrl);
+		reqOpts = {
+			url: resolveUrl(retrievalUrl, api.EXPRESS_URL_END),
+			method: 'GET',
+			responseType: 'json',
+			sessionId
+		};
+	});
+
+	// TODO add to this route time limits for listing
+
+	itAsync('lists messages in inbox', async () => {
+		const opts = copy(reqOpts);
+		
+		// some number of messages at the start of test
+		let rep = await doBodylessRequest<api.Reply>(opts);
+		expect(rep.status).withContext('normal status reply').toBe(api.SC.ok);
+		expect(Array.isArray(rep.data)).toBe(true);
+		const initNumOfMsgs = rep.data.length;
+		
+		// add one message, and see a change
+		const msgId = await sendMsg(deliveryUrl, user1.id, msg);
+		rep = await doBodylessRequest<api.Reply>(opts);
+		expect(rep.status).withContext('normal status reply').toBe(api.SC.ok);
+		expect(Array.isArray(rep.data)).toBe(true);
+		expect(rep.data).toContain(msgId);
+		expect(rep.data.length).toBe(initNumOfMsgs + 1);
+		
+	});
+
+	itAsync(`requires open session`, async () => {
+		const opts = copy(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(opts);
+	});
+
+	itAsync(`doesn't list messages that ain't completely sent`, async () => {
+		const opts = copy(reqOpts);
+		let lst = (await doBodylessRequest<api.Reply>(opts)).data;
+		const initMsgNum = lst.length;
+
+		// start prolonged message sending
+		const longSending = msgSendingSteps(deliveryUrl, user1.id, msg);
+		const { value: msgId1 } = (await longSending.next());
+		lst = (await doBodylessRequest<api.Reply>(opts)).data;
+		expect(lst.length).toBe(initMsgNum);
+		expect(lst).not.toContain(msgId1);
+
+		// add one message completely before listing
+		const msgId2 = await sendMsg(deliveryUrl, user1.id, msg);
+		lst = (await doBodylessRequest<api.Reply>(opts)).data;
+		expect(lst.length).toBe(initMsgNum + 1);
+		expect(lst).toContain(msgId2);
+
+		let done: boolean;
+		do {
+			done = !!(await longSending.next()).done;
+			if (!done) {
+				expect((await doBodylessRequest<api.Reply>(opts)).data)
+				.not.toContain(msgId1);
+			}
+		} while (!done);
+
+		// listing message only when it is completely sent
+		lst = (await doBodylessRequest<api.Reply>(opts)).data;
+		expect(lst.length).toBe(initMsgNum + 2);
+		expect(lst).toContain(msgId1);
+	});
+
+});

package/ts-code/tests/protocols/asmail/retrieval/specs/remove-message.ts

@@ -0,0 +1,74 @@
+/*
+ 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 { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { SpecDescribe, TestSetup, User, msg, ASMailComponent, startSession, sendMsg } from '../test-utils';
+import { resolve as resolveUrl } from 'url';
+import { rmMsg as api } from '../../../../../lib-common/service-api/asmail/retrieval';
+import { RequestOpts, doBodylessRequest } from '../../../../libs-for-tests/xhr-utils';
+import { expectNonAcceptanceOfBadSessionId } from '../../../../shared-checks/requests';
+import { copy } from '../../../../libs-for-tests/json-copy';
+
+export const specs: SpecDescribe = {
+	description: `Request to remove message from inbox`
+};
+
+specs.definition = (setup: () => TestSetup) => (() => {
+	
+	let asmailServer: ASMailComponent;
+	let retrievalUrl: string;
+	let deliveryUrl: string;
+	let user1: User;
+	let reqOpts: RequestOpts
+
+	beforeEachAsync(async () => {
+		asmailServer = setup().asmailServer;
+		retrievalUrl = await asmailServer.getRetrievalUrl();
+		deliveryUrl = await asmailServer.getDeliveryUrl();
+		user1 = setup().user1;
+		const sessionId = await startSession(user1, retrievalUrl);
+		reqOpts = {
+			url: resolveUrl(retrievalUrl, api.genUrlEnd('some-msg')),
+			method: 'DELETE',
+			sessionId
+		};
+	});
+		
+	itAsync('removes messages from inbox', async () => {
+		const msgId = await sendMsg(deliveryUrl, user1.id, msg);
+		expect(await asmailServer.msgExists(user1.id, msgId, true)).toBeTruthy();
+		
+		const opts = copy(reqOpts);
+		opts.url = resolveUrl(retrievalUrl, api.genUrlEnd(msgId));
+		
+		const rep = await doBodylessRequest<void>(opts);
+		expect(rep.status).withContext('status when message was found and removed').toBe(api.SC.ok);
+		expect(await asmailServer.msgExists(user1.id, msgId, true)).withContext('message should be removed from the server').toBeFalsy();
+	});
+
+	itAsync(`returns an error when message is unknown`, async () => {
+		const opts = copy(reqOpts);
+		const rep = await doBodylessRequest<void>(opts);
+		expect(rep.status).withContext('status for unknown message').toBe(api.SC.unknownMsg);
+	});
+
+	itAsync(`requires open session`, async () => {
+		const opts = copy(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(opts);
+	});
+
+});

package/ts-code/tests/protocols/asmail/retrieval/test-utils.ts

@@ -0,0 +1,60 @@
+/*
+ Copyright (C) 2017 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 { ASMailComponent } from '../../../libs-for-tests/server-components/asmail';
+import { User, doMailerIdLogin } from '../../../libs-for-tests/mailerid';
+import { GenericSpecDescribe } from '../../../libs-for-tests/spec-assembly';
+import { bytesSync as randomBytes } from '../../../../lib-common/random-node';
+import { Msg, Obj } from '../../../libs-for-tests/asmail';
+import { resolve as resolveUrl } from 'url';
+import * as api from '../../../../lib-common/service-api/asmail/retrieval';
+
+export { ASMailComponent } from '../../../libs-for-tests/server-components/asmail';
+export { User } from '../../../libs-for-tests/mailerid';
+export { sendMsg, Obj } from '../../../libs-for-tests/asmail';
+
+export interface TestSetup {
+	asmailServer: ASMailComponent;
+	user1: User;
+	user2: User;
+}
+
+export type SpecDescribe = GenericSpecDescribe<TestSetup>;
+	
+export const obj1: Obj = {
+	objId: 'aaaa',
+	header: randomBytes(100),
+	segs: randomBytes(573)
+};
+export const obj2: Obj = {
+	objId: 'bbbb',
+	header: randomBytes(100),
+	segs: randomBytes(20*1024 + 7)
+};
+export const msg: Msg = {
+	cryptoMeta: { pid: 'xxxx' },
+	msgObjs: [ obj1, obj2 ]
+}
+	
+export async function startSession(user: User, retrievalUrl: string): Promise<string> {
+	return await doMailerIdLogin(
+		resolveUrl(retrievalUrl, api.midLogin.MID_URL_PART),
+		user
+	);
+}
+
+Object.freeze(exports);

package/ts-code/tests/protocols/asmail/retrieval.ts

@@ -0,0 +1,115 @@
+/*
+ Copyright (C) 2016, 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 { afterAllAsync, beforeAllAsync, itAsync } from '../../libs-for-tests/async-jasmine';
+import { ASMailComponent } from '../../libs-for-tests/server-components/asmail';
+import { User } from '../../libs-for-tests/mailerid';
+import { RequestOpts, doBodylessRequest } from '../../libs-for-tests/xhr-utils';
+import { expectNonAcceptanceOfBadSessionId, expectNonAcceptanceOfNonEmptyBody } from '../../shared-checks/requests';
+import { midLoginSpecs } from '../../shared-checks/check-mid-login';
+import { resolve as resolveUrl } from 'url';
+import * as api from '../../../lib-common/service-api/asmail/retrieval';
+import { bytesSync as randomBytes } from '../../../lib-common/random-node';
+import { Msg } from '../../libs-for-tests/asmail';
+import { addSpecsFrom } from '../../libs-for-tests/spec-assembly';
+import { join as joinPaths } from 'path';
+import { startSession } from './retrieval/test-utils';
+
+const SPECS_FOLDER = joinPaths(__dirname, './retrieval/specs');
+
+describe('ASMail retrieval service', () => {
+	
+	let asmailServer: ASMailComponent;
+	const midServiceDomain = 'localhost';
+	const signupDomains = [ 'company.inc', 'personal.net' ];
+	let user1: User;
+	let user2: User;
+	let retrievalUrl: string;
+	let deliveryUrl: string;
+	
+	const msg: Msg = {
+		cryptoMeta: {
+			pid: 'ephemeral pair id'
+		},
+		msgObjs: [ {
+			objId: 'aaaa',
+			header: randomBytes(100),
+			segs: randomBytes(573)
+		}, {
+			objId: 'bbbb',
+			header: randomBytes(100),
+			segs: randomBytes(2*1024 + 7)
+		} ]
+	};
+	
+	beforeAllAsync(async () => {
+		asmailServer = new ASMailComponent(signupDomains, midServiceDomain);
+		await asmailServer.start();
+		retrievalUrl = await asmailServer.getRetrievalUrl();
+		if (!retrievalUrl.endsWith('/')) { retrievalUrl += '/'; }
+		deliveryUrl = await asmailServer.getDeliveryUrl();
+		if (!deliveryUrl.endsWith('/')) { deliveryUrl += '/'; }
+		user1 = await asmailServer.addUser(
+			`Bob Johnson @${signupDomains[0]}`
+		);
+		user2 = await asmailServer.addUser(
+			`William Young @${signupDomains[1]}`
+		);
+	});
+	
+	afterAllAsync(async () => {
+		await asmailServer.stop();
+		asmailServer = (undefined as any);
+	});
+	
+	describe('session', () => {
+
+		describe('MailerId login', midLoginSpecs(
+			() => resolveUrl(retrievalUrl, api.midLogin.MID_URL_PART),
+			() => user1
+		));
+		
+		itAsync('closing session', async () => {
+			const sessionId = await startSession(user1, retrievalUrl);
+			
+			const reqOpts: RequestOpts = {
+				url: resolveUrl(retrievalUrl, api.closeSession.URL_END),
+				method: 'POST',
+				sessionId
+			};
+			
+			// normal closing of a session
+			let rep = await doBodylessRequest<void>(reqOpts);
+			expect(rep.status).withContext('status for successful closing of session').toBe(200);
+			
+			// repeated call should see invalid session response
+			rep = await doBodylessRequest<void>(reqOpts);
+			expect(rep.status).toBe(api.ERR_SC.needAuth);
+			
+			reqOpts.sessionId = await startSession(user1, retrievalUrl);
+			
+			await expectNonAcceptanceOfNonEmptyBody(reqOpts);
+			
+			await expectNonAcceptanceOfBadSessionId(reqOpts);
+			
+		});
+
+	});
+	
+	addSpecsFrom(SPECS_FOLDER, () => ({ asmailServer, user1, user2 }));
+	
+});