copy apps-engine tests

Author: d-gubert

eslint.config.mjs

@@ -338,7 +338,7 @@ export default [
 		},
 	},
 	{
-		files: ['packages/apps-engine/tests/**/*'],
+		files: ['packages/apps-engine/tests/**/*', 'packages/apps/tests/**/*'],
 		rules: {
 			'@typescript-eslint/no-non-null-assertion': 'off',
 			'testing-library/no-await-sync-queries': 'off',

packages/apps/.gitignore

@@ -1 +1,2 @@
 .deno-cache/
+/tests/test-data/dbs

packages/apps/tests/server/AppManager.test.ts

@@ -0,0 +1,279 @@
+import * as assert from 'node:assert';
+import { describe, it, afterEach, mock } from 'node:test';
+
+import { AppManager } from '../../src/server/AppManager';
+import { AppBridges } from '../../src/server/bridges';
+import { AppCompiler, AppPackageParser } from '../../src/server/compiler';
+import {
+	AppAccessorManager,
+	AppApiManager,
+	AppExternalComponentManager,
+	AppListenerManager,
+	AppSettingsManager,
+	AppSlashCommandManager,
+	AppVideoConfProviderManager,
+	AppOutboundCommunicationProviderManager,
+} from '../../src/server/managers';
+import type { AppLogStorage, AppMetadataStorage, AppSourceStorage } from '../../src/server/storage';
+import { SimpleClass, TestData, TestInfastructureSetup } from '../test-data/utilities';
+
+describe('AppManager', () => {
+	const testingInfastructure = new TestInfastructureSetup();
+
+	afterEach(() => {
+		AppManager.Instance = undefined;
+		mock.restoreAll();
+	});
+
+	it('Setup of the AppManager', () => {
+		const manager = new AppManager({
+			metadataStorage: testingInfastructure.getAppStorage(),
+			logStorage: testingInfastructure.getLogStorage(),
+			bridges: testingInfastructure.getAppBridges(),
+			sourceStorage: testingInfastructure.getSourceStorage(),
+			tempFilePath: testingInfastructure.getTempFilePath(),
+		});
+
+		assert.strictEqual(manager.getStorage(), testingInfastructure.getAppStorage());
+		assert.strictEqual(manager.getLogStorage(), testingInfastructure.getLogStorage());
+		// NOTE: manager.getBridges() returns a proxy, so they are vlaue equality instead of reference equality
+		assert.deepStrictEqual(manager.getBridges(), testingInfastructure.getAppBridges());
+		assert.strictEqual(manager.areAppsLoaded(), false);
+
+		assert.throws(
+			() =>
+				new AppManager({
+					metadataStorage: {} as AppMetadataStorage,
+					logStorage: {} as AppLogStorage,
+					bridges: {} as AppBridges,
+					sourceStorage: {} as AppSourceStorage,
+					tempFilePath: 'temp-file-path',
+				}),
+			{
+				name: 'Error',
+				message: 'There is already a valid AppManager instance',
+			},
+		);
+	});
+
+	it('Invalid Storage and Bridge', () => {
+		const invalid = new SimpleClass();
+
+		assert.throws(
+			() =>
+				new AppManager({
+					metadataStorage: invalid as any,
+					logStorage: invalid as any,
+					bridges: invalid as any,
+					sourceStorage: invalid as any,
+					tempFilePath: 'temp-file-path',
+				}),
+			{
+				name: 'Error',
+				message: 'Invalid instance of the AppMetadataStorage',
+			},
+		);
+
+		assert.throws(
+			() =>
+				new AppManager({
+					metadataStorage: testingInfastructure.getAppStorage(),
+					logStorage: invalid as any,
+					bridges: invalid as any,
+					sourceStorage: invalid as any,
+					tempFilePath: 'temp-file-path',
+				}),
+			{
+				name: 'Error',
+				message: 'Invalid instance of the AppLogStorage',
+			},
+		);
+
+		assert.throws(
+			() =>
+				new AppManager({
+					metadataStorage: testingInfastructure.getAppStorage(),
+					logStorage: testingInfastructure.getLogStorage(),
+					bridges: invalid as any,
+					sourceStorage: invalid as any,
+					tempFilePath: 'temp-file-path',
+				}),
+			{
+				name: 'Error',
+				message: 'Invalid instance of the AppBridges',
+			},
+		);
+
+		assert.throws(
+			() =>
+				new AppManager({
+					metadataStorage: testingInfastructure.getAppStorage(),
+					logStorage: testingInfastructure.getLogStorage(),
+					bridges: testingInfastructure.getAppBridges(),
+					sourceStorage: invalid as any,
+					tempFilePath: testingInfastructure.getTempFilePath(),
+				}),
+			{
+				name: 'Error',
+				message: 'Invalid instance of the AppSourceStorage',
+			},
+		);
+	});
+
+	it('Ensure Managers are Valid Types', () => {
+		const manager = new AppManager({
+			metadataStorage: testingInfastructure.getAppStorage(),
+			logStorage: testingInfastructure.getLogStorage(),
+			bridges: testingInfastructure.getAppBridges(),
+			sourceStorage: testingInfastructure.getSourceStorage(),
+			tempFilePath: testingInfastructure.getTempFilePath(),
+		});
+
+		assert.ok(manager.getParser() instanceof AppPackageParser);
+		assert.ok(manager.getCompiler() instanceof AppCompiler);
+		assert.ok(manager.getAccessorManager() instanceof AppAccessorManager);
+		assert.ok(manager.getBridges() instanceof AppBridges);
+		assert.ok(manager.getListenerManager() instanceof AppListenerManager);
+		assert.ok(manager.getCommandManager() instanceof AppSlashCommandManager);
+		assert.ok(manager.getExternalComponentManager() instanceof AppExternalComponentManager);
+		assert.ok(manager.getApiManager() instanceof AppApiManager);
+		assert.ok(manager.getSettingsManager() instanceof AppSettingsManager);
+		assert.ok(manager.getVideoConfProviderManager() instanceof AppVideoConfProviderManager);
+		assert.ok(manager.getOutboundCommunicationProviderManager() instanceof AppOutboundCommunicationProviderManager);
+	});
+
+	it('Update Apps Marketplace Info - Apps without subscription info are skipped', async () => {
+		const manager = new AppManager({
+			metadataStorage: testingInfastructure.getAppStorage(),
+			logStorage: testingInfastructure.getLogStorage(),
+			bridges: testingInfastructure.getAppBridges(),
+			sourceStorage: testingInfastructure.getSourceStorage(),
+			tempFilePath: testingInfastructure.getTempFilePath(),
+		});
+
+		const appsOverview = TestData.getAppsOverview();
+		appsOverview[0].latest.subscriptionInfo = undefined; // No subscription info
+
+		// Mock the apps Map to return our mock app
+		(manager as any).apps = new Map([['test-app', TestData.getMockApp(TestData.getAppStorageItem(), manager)]]);
+
+		const updatePartialAndReturnDocumentSpy = mock.method(manager.getStorage(), 'updatePartialAndReturnDocument', () => Promise.resolve());
+
+		// Should not throw and complete successfully
+		await manager.updateAppsMarketplaceInfo(appsOverview);
+
+		assert.strictEqual(updatePartialAndReturnDocumentSpy.mock.calls.length, 0);
+	});
+
+	it('Update Apps Marketplace Info - Apps not found in manager are skipped', async () => {
+		const manager = new AppManager({
+			metadataStorage: testingInfastructure.getAppStorage(),
+			logStorage: testingInfastructure.getLogStorage(),
+			bridges: testingInfastructure.getAppBridges(),
+			sourceStorage: testingInfastructure.getSourceStorage(),
+			tempFilePath: testingInfastructure.getTempFilePath(),
+		});
+
+		const appsOverview = TestData.getAppsOverview();
+		appsOverview[0].latest.id = 'nonexistent-app'; // App not in manager
+
+		// Mock the apps Map to return our mock app
+		(manager as any).apps = new Map([['test-app', TestData.getMockApp(TestData.getAppStorageItem(), manager)]]);
+
+		const updatePartialAndReturnDocumentSpy = mock.method(manager.getStorage(), 'updatePartialAndReturnDocument', () => Promise.resolve());
+
+		// Should not throw and complete successfully
+		await manager.updateAppsMarketplaceInfo(appsOverview);
+
+		assert.strictEqual(updatePartialAndReturnDocumentSpy.mock.calls.length, 0);
+	});
+
+	it('Update Apps Marketplace Info - Apps with same license are skipped', async () => {
+		const manager = new AppManager({
+			metadataStorage: testingInfastructure.getAppStorage(),
+			logStorage: testingInfastructure.getLogStorage(),
+			bridges: testingInfastructure.getAppBridges(),
+			sourceStorage: testingInfastructure.getSourceStorage(),
+			tempFilePath: testingInfastructure.getTempFilePath(),
+		});
+
+		const sameLicenseData = 'same-license-data';
+		const existingSubscriptionInfo = TestData.getMarketplaceSubscriptionInfo({
+			license: { license: sameLicenseData, version: 1, expireDate: new Date('2023-01-01') },
+		});
+
+		const mockStorageItem = TestData.getAppStorageItem({
+			marketplaceInfo: [TestData.getMarketplaceInfo({ subscriptionInfo: existingSubscriptionInfo })],
+		});
+
+		const mockApp = TestData.getMockApp(mockStorageItem, manager);
+
+		// Mock the apps Map to return our mock app
+		(manager as any).apps = new Map([['test-app', mockApp]]);
+
+		const appsOverview = TestData.getAppsOverview(
+			TestData.getMarketplaceSubscriptionInfo({
+				license: { license: sameLicenseData, version: 1, expireDate: new Date('2023-01-01') },
+			}),
+		);
+
+		const updatePartialAndReturnDocumentSpy = mock.method(manager.getStorage(), 'updatePartialAndReturnDocument', () => Promise.resolve());
+
+		// Should not throw and complete successfully
+		await manager.updateAppsMarketplaceInfo(appsOverview);
+
+		// Verify the subscription info was not updated (should remain the same)
+		assert.strictEqual(mockStorageItem.marketplaceInfo[0].subscriptionInfo.seats, 10); // Original value
+		assert.strictEqual(updatePartialAndReturnDocumentSpy.mock.calls.length, 0);
+	});
+
+	it('Update Apps Marketplace Info - Subscription info is updated and app is signed', async () => {
+		const manager = new AppManager({
+			metadataStorage: testingInfastructure.getAppStorage(),
+			logStorage: testingInfastructure.getLogStorage(),
+			bridges: testingInfastructure.getAppBridges(),
+			sourceStorage: testingInfastructure.getSourceStorage(),
+			tempFilePath: testingInfastructure.getTempFilePath(),
+		});
+
+		const existingSubscriptionInfo = TestData.getMarketplaceSubscriptionInfo({
+			license: { license: 'old-license-data', version: 1, expireDate: new Date('2023-01-01') },
+		});
+
+		const newSubscriptionInfo = TestData.getMarketplaceSubscriptionInfo({
+			seats: 20,
+			maxSeats: 200,
+			startDate: '2023-02-01',
+			periodEnd: '2024-01-31',
+			license: { license: 'new-license-data', version: 1, expireDate: new Date('2026-01-01') },
+		});
+
+		const mockStorageItem = TestData.getAppStorageItem({
+			marketplaceInfo: [TestData.getMarketplaceInfo({ subscriptionInfo: existingSubscriptionInfo })],
+		});
+
+		const mockApp = TestData.getMockApp(mockStorageItem, manager);
+
+		mock.method(manager.getSignatureManager(), 'signApp', () => Promise.resolve('signed-app-data'));
+		mock.method(mockApp, 'validateLicense', () => Promise.resolve());
+
+		const updatePartialAndReturnDocumentSpy = mock.method(manager.getStorage(), 'updatePartialAndReturnDocument', () =>
+			Promise.resolve(mockStorageItem),
+		);
+
+		// Mock the apps Map and dependencies
+		(manager as any).apps = new Map([['test-app', mockApp]]);
+
+		const appsOverview = TestData.getAppsOverview(newSubscriptionInfo);
+
+		await manager.updateAppsMarketplaceInfo(appsOverview);
+
+		const expectedStorageItem = mockApp.getStorageItem();
+
+		// Verify the subscription info was updated
+		assert.strictEqual(expectedStorageItem.marketplaceInfo[0].subscriptionInfo.seats, 20);
+		assert.strictEqual(expectedStorageItem.marketplaceInfo[0].subscriptionInfo.license.license, 'new-license-data');
+		assert.strictEqual(expectedStorageItem.signature, 'signed-app-data');
+		assert.strictEqual(updatePartialAndReturnDocumentSpy.mock.calls.length, 1);
+	});
+});