chore: convert apps-engine tests from Alsatian to Node.js built-in test framework

packages/apps-engine/tests/node-tests/server/accessors/EnvironmentRead.test.ts

@@ -0,0 +1,20 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import type { IEnvironmentalVariableRead, IServerSettingRead, ISettingRead } from '../../../../src/definition/accessors';
+import { EnvironmentRead } from '../../../../src/server/accessors';
+
+describe('EnvironmentRead', () => {
+	it('useEnvironmentRead', () => {
+		const evr = {} as IEnvironmentalVariableRead;
+		const ssr = {} as IServerSettingRead;
+		const sr = {} as ISettingRead;
+
+		assert.doesNotThrow(() => new EnvironmentRead(sr, ssr, evr));
+
+		const er = new EnvironmentRead(sr, ssr, evr);
+		assert.ok(er.getSettings() !== undefined);
+		assert.ok(er.getServerSettings() !== undefined);
+		assert.ok(er.getEnvironmentVariables() !== undefined);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/EnvironmentWrite.test.ts

@@ -0,0 +1,18 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import type { IServerSettingUpdater, ISettingUpdater } from '../../../../src/definition/accessors';
+import { EnvironmentWrite } from '../../../../src/server/accessors';
+
+describe('EnvironmentWrite', () => {
+	it('useEnvironmentWrite', () => {
+		const sr = {} as ISettingUpdater;
+		const serverSettings = {} as IServerSettingUpdater;
+
+		assert.doesNotThrow(() => new EnvironmentWrite(sr, serverSettings));
+
+		const er = new EnvironmentWrite(sr, serverSettings);
+		assert.ok(er.getSettings() !== undefined);
+		assert.ok(er.getServerSettings() !== undefined);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/EnvironmentalVariableRead.test.ts

@@ -0,0 +1,28 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { EnvironmentalVariableRead } from '../../../../src/server/accessors';
+import type { EnvironmentalVariableBridge } from '../../../../src/server/bridges';
+
+describe('EnvironmentalVariableRead', () => {
+	it('useEnvironmentalVariableRead', async () => {
+		const mockEnvVarBridge = {
+			doGetValueByName(name: string, appId: string): Promise<string> {
+				return Promise.resolve('value');
+			},
+			doIsReadable(name: string, appId: string): Promise<boolean> {
+				return Promise.resolve(true);
+			},
+			doIsSet(name: string, appId: string): Promise<boolean> {
+				return Promise.resolve(false);
+			},
+		} as EnvironmentalVariableBridge;
+
+		assert.doesNotThrow(() => new EnvironmentalVariableRead(mockEnvVarBridge, 'testing'));
+
+		const evr = new EnvironmentalVariableRead(mockEnvVarBridge, 'testing');
+		assert.strictEqual(await evr.getValueByName('testing'), 'value');
+		assert.ok(await evr.isReadable('testing'));
+		assert.ok(!(await evr.isSet('testing2')));
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/MessageExtender.test.ts

@@ -0,0 +1,46 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import type { IMessage } from '../../../../src/definition/messages';
+import { MessageExtender } from '../../../../src/server/accessors';
+import { TestData } from '../../../test-data/utilities';
+
+describe('MessageExtender', () => {
+	it('basicMessageExtender', () => {
+		assert.doesNotThrow(() => new MessageExtender({} as IMessage));
+		assert.doesNotThrow(() => new MessageExtender(TestData.getMessage()));
+	});
+
+	it('usingMessageExtender', () => {
+		const msg: IMessage = {} as IMessage;
+		const me = new MessageExtender(msg);
+
+		assert.ok(msg.attachments !== undefined);
+		assert.strictEqual(msg.attachments.length, 0);
+		assert.strictEqual(me.addCustomField('thing', 'value'), me);
+		assert.ok(msg.customFields !== undefined);
+		assert.strictEqual(msg.customFields.thing, 'value');
+		assert.throws(
+			() => me.addCustomField('thing', 'second'),
+			{
+				name: 'Error',
+				message: 'The message already contains a custom field by the key: thing',
+			},
+		);
+		assert.throws(
+			() => me.addCustomField('thing.', 'second'),
+			{
+				name: 'Error',
+				message: 'The given key contains a period, which is not allowed. Key: thing.',
+			},
+		);
+
+		assert.strictEqual(me.addAttachment({}), me);
+		assert.strictEqual(msg.attachments.length, 1);
+		assert.strictEqual(me.addAttachments([{ collapsed: true }, { color: '#f00' }]), me);
+		assert.strictEqual(msg.attachments.length, 3);
+
+		assert.notStrictEqual(me.getMessage(), msg);
+		assert.deepStrictEqual(me.getMessage(), msg);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/Modify.test.ts

@@ -0,0 +1,46 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { Modify } from '../../../../src/server/accessors';
+import type {
+	AppBridges,
+	MessageBridge,
+	ModerationBridge,
+	SchedulerBridge,
+	UiInteractionBridge,
+	UserBridge,
+} from '../../../../src/server/bridges';
+import type { OAuthAppsBridge } from '../../../../src/server/bridges/OAuthAppsBridge';
+
+describe('Modify', () => {
+	it('useModify', () => {
+		const mockAppBridges = {
+			getUserBridge(): UserBridge {
+				return {} as UserBridge;
+			},
+			getMessageBridge(): MessageBridge {
+				return {} as MessageBridge;
+			},
+			getUiInteractionBridge(): UiInteractionBridge {
+				return {} as UiInteractionBridge;
+			},
+			getSchedulerBridge() {
+				return {} as SchedulerBridge;
+			},
+			getOAuthAppsBridge() {
+				return {} as OAuthAppsBridge;
+			},
+			getModerationBridge() {
+				return {} as ModerationBridge;
+			},
+		} as AppBridges;
+
+		assert.doesNotThrow(() => new Modify(mockAppBridges, 'testing'));
+
+		const md = new Modify(mockAppBridges, 'testing');
+		assert.ok(md.getCreator() !== undefined);
+		assert.ok(md.getExtender() !== undefined);
+		assert.ok(md.getNotifier() !== undefined);
+		assert.ok(md.getUpdater() !== undefined);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/Notifier.test.ts

@@ -0,0 +1,31 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import type { IMessage } from '../../../../src/definition/messages';
+import type { IRoom } from '../../../../src/definition/rooms';
+import type { IUser } from '../../../../src/definition/users';
+import { MessageBuilder, Notifier } from '../../../../src/server/accessors';
+import type { MessageBridge, UserBridge } from '../../../../src/server/bridges';
+import { TestData } from '../../../test-data/utilities';
+
+describe('Notifier', () => {
+	it('useNotifier', async () => {
+		const mockUserBridge = {} as UserBridge;
+		const mockMsgBridge = {
+			doNotifyUser(user: IUser, msg: IMessage, appId: string): Promise<void> {
+				// TODO: Spy on these and ensure they're called with the right parameters
+				return Promise.resolve();
+			},
+			doNotifyRoom(room: IRoom, msg: IMessage, appId: string): Promise<void> {
+				return Promise.resolve();
+			},
+		} as MessageBridge;
+
+		assert.doesNotThrow(() => new Notifier(mockUserBridge, mockMsgBridge, 'testing'));
+
+		const noti = new Notifier(mockUserBridge, mockMsgBridge, 'testing');
+		await assert.doesNotReject(() => noti.notifyRoom(TestData.getRoom(), TestData.getMessage()));
+		await assert.doesNotReject(() => noti.notifyUser(TestData.getUser(), TestData.getMessage()));
+		assert.ok(noti.getMessageBuilder() instanceof MessageBuilder);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/PersistenceRead.test.ts

@@ -0,0 +1,26 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import type { RocketChatAssociationRecord } from '../../../../src/definition/metadata';
+import { PersistenceRead } from '../../../../src/server/accessors';
+import type { PersistenceBridge } from '../../../../src/server/bridges';
+
+describe('PersistenceRead', () => {
+	it('usePersistenceRead', async () => {
+		const mockPersisBridge = {
+			doReadById(id: string, appId: string): Promise<object> {
+				return Promise.resolve({ id, appId });
+			},
+			doReadByAssociations(assocs: Array<RocketChatAssociationRecord>, appId: string): Promise<Array<object>> {
+				return Promise.resolve([{ appId }]);
+			},
+		} as PersistenceBridge;
+
+		assert.doesNotThrow(() => new PersistenceRead(mockPersisBridge, 'testing'));
+
+		const pr = new PersistenceRead(mockPersisBridge, 'testing');
+		assert.ok((await pr.read('thing')) !== undefined);
+		assert.ok((await pr.readByAssociation({} as RocketChatAssociationRecord)) !== undefined);
+		assert.ok((await pr.readByAssociations([{} as RocketChatAssociationRecord])) !== undefined);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/RoomExtender.test.ts

@@ -0,0 +1,55 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import type { IRoom } from '../../../../src/definition/rooms';
+import { RoomExtender } from '../../../../src/server/accessors';
+import { TestData } from '../../../test-data/utilities';
+
+describe('RoomExtender', () => {
+	it('basicRoomExtender', () => {
+		assert.doesNotThrow(() => new RoomExtender({} as IRoom));
+		assert.doesNotThrow(() => new RoomExtender(TestData.getRoom()));
+	});
+
+	it('usingRoomExtender', () => {
+		const room: IRoom = {} as IRoom;
+		const re = new RoomExtender(room);
+
+		assert.ok(room.customFields === undefined);
+		assert.strictEqual(re.addCustomField('thing', 'value'), re);
+		assert.ok(room.customFields !== undefined);
+		assert.strictEqual(room.customFields.thing as any, 'value');
+		assert.throws(
+			() => re.addCustomField('thing', 'second'),
+			{
+				name: 'Error',
+				message: 'The room already contains a custom field by the key: thing',
+			},
+		);
+		assert.throws(
+			() => re.addCustomField('thing.', 'second'),
+			{
+				name: 'Error',
+				message: 'The given key contains a period, which is not allowed. Key: thing.',
+			},
+		);
+
+		assert.ok(room.usernames === undefined);
+		assert.strictEqual(re.addMember(TestData.getUser('theId', 'bradley')), re);
+		assert.ok(room.usernames === undefined);
+		assert.ok(re.getMembersBeingAdded() !== undefined);
+		assert.ok(re.getMembersBeingAdded().length > 0);
+		assert.ok(re.getMembersBeingAdded()[0].length !== undefined);
+		assert.strictEqual(re.getMembersBeingAdded()[0].username, 'bradley');
+		assert.throws(
+			() => re.addMember(TestData.getUser('theSameUsername', 'bradley')),
+			{
+				name: 'Error',
+				message: 'The user is already in the room.',
+			},
+		);
+
+		assert.notStrictEqual(re.getRoom(), room);
+		assert.deepStrictEqual(re.getRoom(), room);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/ServerSettingRead.test.ts

@@ -0,0 +1,45 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import type { ISetting } from '../../../../src/definition/settings';
+import { ServerSettingRead } from '../../../../src/server/accessors';
+import type { ServerSettingBridge } from '../../../../src/server/bridges';
+import { TestData } from '../../../test-data/utilities';
+
+describe('ServerSettingRead', () => {
+	it('expectDataFromRoomRead', async () => {
+		const setting = TestData.getSetting('testing');
+
+		const theSetting = setting;
+		const mockServerSettingBridge = {
+			doGetOneById(id: string, appId: string): Promise<ISetting> {
+				return Promise.resolve(id === 'testing' ? theSetting : undefined);
+			},
+			doIsReadableById(id: string, appId: string): Promise<boolean> {
+				return Promise.resolve(true);
+			},
+		} as ServerSettingBridge;
+
+		assert.doesNotThrow(() => new ServerSettingRead(mockServerSettingBridge, 'testing-app'));
+
+		const ssr = new ServerSettingRead(mockServerSettingBridge, 'testing-app');
+
+		assert.ok((await ssr.getOneById('testing')) !== undefined);
+		assert.deepStrictEqual(await ssr.getOneById('testing'), setting);
+		assert.deepStrictEqual(await ssr.getValueById('testing'), setting.packageValue);
+		setting.value = 'theValue';
+		assert.strictEqual(await ssr.getValueById('testing'), 'theValue');
+		await assert.rejects(
+			async () => ssr.getValueById('fake'),
+			{
+				name: 'Error',
+				message: 'No Server Setting found, or it is unaccessible, by the id of "fake".',
+			},
+		);
+		await assert.rejects(() => ssr.getAll(), {
+			name: 'Error',
+			message: 'Method not implemented.',
+		});
+		assert.strictEqual(await ssr.isReadableById('testing'), true);
+	});
+});

packages/apps-engine/tests/node-tests/server/accessors/ServerSettingsModify.test.ts

@@ -0,0 +1,53 @@
+import * as assert from 'node:assert';
+import { describe, it, mock } from 'node:test';
+
+import type { ISetting } from '../../../../src/definition/settings';
+import { ServerSettingsModify } from '../../../../src/server/accessors';
+import type { ServerSettingBridge } from '../../../../src/server/bridges';
+import { TestData } from '../../../test-data/utilities';
+
+describe('ServerSettingsModify', () => {
+	it('useServerSettingsModify', async () => {
+		const setting = TestData.getSetting();
+		const mockAppId = 'testing-app';
+		const mockServerSettingBridge = {
+			doHideGroup(name: string, appId: string): Promise<void> {
+				return Promise.resolve();
+			},
+			doHideSetting(id: string, appId: string): Promise<void> {
+				return Promise.resolve();
+			},
+			doUpdateOne(setting: ISetting, appId: string): Promise<void> {
+				return Promise.resolve();
+			},
+			doIncrementValue(id: ISetting['id'], value: number, appId: string): Promise<void> {
+				return Promise.resolve();
+			},
+		} as ServerSettingBridge;
+
+		assert.doesNotThrow(() => new ServerSettingsModify(mockServerSettingBridge, mockAppId));
+
+		const hideGroupSpy = mock.method(mockServerSettingBridge, 'doHideGroup');
+		const hideSettingSpy = mock.method(mockServerSettingBridge, 'doHideSetting');
+		const updateOneSpy = mock.method(mockServerSettingBridge, 'doUpdateOne');
+		const incrementValueSpy = mock.method(mockServerSettingBridge, 'doIncrementValue');
+
+		const ssm = new ServerSettingsModify(mockServerSettingBridge, mockAppId);
+
+		assert.ok((await ssm.hideGroup('api')) === undefined);
+		assert.strictEqual(hideGroupSpy.mock.calls.length, 1);
+		assert.deepStrictEqual(hideGroupSpy.mock.calls[0].arguments, ['api', mockAppId]);
+
+		assert.ok((await ssm.hideSetting('api')) === undefined);
+		assert.strictEqual(hideSettingSpy.mock.calls.length, 1);
+		assert.deepStrictEqual(hideSettingSpy.mock.calls[0].arguments, ['api', mockAppId]);
+
+		assert.ok((await ssm.modifySetting(setting)) === undefined);
+		assert.strictEqual(updateOneSpy.mock.calls.length, 1);
+		assert.deepStrictEqual(updateOneSpy.mock.calls[0].arguments, [setting, mockAppId]);
+
+		assert.ok((await ssm.incrementValue(setting.id, 5)) === undefined);
+		assert.strictEqual(incrementValueSpy.mock.calls.length, 1);
+		assert.deepStrictEqual(incrementValueSpy.mock.calls[0].arguments, [setting.id, 5, mockAppId]);
+	});
+});