snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/ee/tests/unit/server/airgappedRestrictions/airGappedRestrictionsWrapper.spec.ts

@@ -0,0 +1,34 @@
+import { expect } from 'chai';
+import proxyquire from 'proxyquire';
+import sinon from 'sinon';
+
+import { applyAirGappedRestrictionsValidation } from '../../../../../server/lib/cloud/license/airGappedRestrictionsWrapper';
+
+let restrictionFlag = true;
+
+const airgappedModule = {
+	get restricted() {
+		return restrictionFlag;
+	},
+};
+
+proxyquire.noCallThru().load('../../../../server/patches/airGappedRestrictionsWrapper.ts', {
+	'@rocket.chat/license': {
+		AirGappedRestriction: airgappedModule,
+	},
+	'../../../server/lib/cloud/license/airGappedRestrictionsWrapper': {
+		applyAirGappedRestrictionsValidation,
+	},
+});
+
+describe('#airGappedRestrictionsWrapper()', () => {
+	it('should throw an error when the workspace is restricted', async () => {
+		await expect(applyAirGappedRestrictionsValidation(sinon.stub())).to.be.rejectedWith('restricted-workspace');
+	});
+	it('should NOT throw an error when the workspace is not restricted', async () => {
+		restrictionFlag = false;
+		const spy = sinon.stub();
+		await expect(applyAirGappedRestrictionsValidation(spy)).to.eventually.equal(undefined);
+		expect(spy.calledOnce).to.be.true;
+	});
+});

apps/meteor/ee/tests/unit/server/airgappedRestrictions/airgappedRestrictions.spec.ts

@@ -0,0 +1,132 @@
+import { Emitter } from '@rocket.chat/emitter';
+import { registerModel } from '@rocket.chat/models';
+import { expect } from 'chai';
+import proxyquire from 'proxyquire';
+import sinon from 'sinon';
+
+let promises: Array<Promise<any>> = [];
+
+class AirgappedRestriction extends Emitter<{ remainingDays: { days: number } }> {
+	computeRestriction = sinon.spy();
+
+	isWarningPeriod = sinon.stub();
+
+	override on(type: any, cb: any): any {
+		const newCb = (...args: any) => {
+			promises.push(cb(...args));
+		};
+		return super.on(type, newCb);
+	}
+}
+
+const airgappedRestrictionObj = new AirgappedRestriction();
+
+const mocks = {
+	sendMessagesToAdmins: ({ msgs }: any) => {
+		msgs({ adminUser: { language: 'pt-br' } });
+	},
+	settingsUpdate: sinon.spy(),
+	notifySetting: sinon.spy(),
+	i18n: sinon.spy(),
+	findLastToken: sinon.stub(),
+};
+
+const licenseMock = {
+	validateCb: async () => undefined,
+	removeCb: async () => undefined,
+	onValidateLicense: async (cb: any) => {
+		licenseMock.validateCb = cb;
+	},
+	onRemoveLicense: async (cb: any) => {
+		licenseMock.removeCb = cb;
+	},
+};
+
+registerModel('IServerEventsModel', {
+	insertOne: () => undefined,
+	createAuditServerEvent: () => undefined,
+} as any);
+
+proxyquire.noCallThru().load('../../../../server/lib/license/airGappedRestrictions.ts', {
+	'@rocket.chat/license': {
+		AirGappedRestriction: airgappedRestrictionObj,
+		License: licenseMock,
+	},
+	'@rocket.chat/models': {
+		Settings: {
+			updateValueById: mocks.settingsUpdate,
+		},
+		Statistics: {
+			findLastStatsToken: mocks.findLastToken,
+		},
+	},
+	'../../../../server/lib/notifyListener': {
+		notifyOnSettingChangedById: mocks.notifySetting,
+	},
+	'../../../../server/lib/i18n': {
+		i18n: {
+			t: mocks.i18n,
+		},
+	},
+	'../../../../server/lib/sendMessagesToAdmins': {
+		sendMessagesToAdmins: mocks.sendMessagesToAdmins,
+	},
+});
+
+describe('airgappedRestrictions', () => {
+	afterEach(() => {
+		Object.values(mocks).forEach((mock) => {
+			if ('resetHistory' in mock) {
+				mock.resetHistory();
+			}
+			if ('reset' in mock) {
+				mock.reset();
+			}
+		});
+		airgappedRestrictionObj.computeRestriction.resetHistory();
+		airgappedRestrictionObj.isWarningPeriod.reset();
+		promises = [];
+	});
+	it('should update setting when restriction is removed', async () => {
+		airgappedRestrictionObj.emit('remainingDays', { days: -1 });
+
+		await Promise.all(promises);
+		expect(mocks.settingsUpdate.calledWith('Cloud_Workspace_AirGapped_Restrictions_Remaining_Days', -1)).to.be.true;
+		expect(mocks.notifySetting.calledWith('Cloud_Workspace_AirGapped_Restrictions_Remaining_Days')).to.be.true;
+		expect(airgappedRestrictionObj.isWarningPeriod.called).to.be.false;
+	});
+
+	it('should update setting when restriction is applied', async () => {
+		airgappedRestrictionObj.emit('remainingDays', { days: 0 });
+
+		await Promise.all(promises);
+		expect(mocks.settingsUpdate.calledWith('Cloud_Workspace_AirGapped_Restrictions_Remaining_Days', 0)).to.be.true;
+		expect(mocks.notifySetting.calledWith('Cloud_Workspace_AirGapped_Restrictions_Remaining_Days')).to.be.true;
+		expect(airgappedRestrictionObj.isWarningPeriod.called).to.be.false;
+	});
+
+	it('should update setting and send rocket.cat message when in warning period', async () => {
+		airgappedRestrictionObj.emit('remainingDays', { days: 1 });
+		airgappedRestrictionObj.isWarningPeriod.returns(true);
+
+		await Promise.all(promises);
+		expect(mocks.settingsUpdate.calledWith('Cloud_Workspace_AirGapped_Restrictions_Remaining_Days', 1)).to.be.true;
+		expect(mocks.notifySetting.calledWith('Cloud_Workspace_AirGapped_Restrictions_Remaining_Days')).to.be.true;
+		expect(airgappedRestrictionObj.isWarningPeriod.called).to.be.true;
+		expect(mocks.i18n.calledWith('AirGapped_Restriction_Warning', { lng: 'pt-br' }));
+	});
+
+	it('should recompute restriction if license is applied', async () => {
+		mocks.findLastToken.returns('token');
+		await licenseMock.validateCb();
+		expect(mocks.findLastToken.calledOnce).to.be.true;
+		expect(airgappedRestrictionObj.computeRestriction.calledWith('token')).to.be.true;
+	});
+
+	it('should recompute restriction if license is removed', async () => {
+		mocks.findLastToken.returns('token');
+		await licenseMock.removeCb();
+		expect(mocks.findLastToken.calledOnce).to.be.true;
+		expect(airgappedRestrictionObj.computeRestriction.calledWith('token')).to.be.true;
+	});
+});