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

apps/meteor/tests/unit/server/lib/cloud/registerPreIntentWorkspaceWizard.spec.ts

@@ -0,0 +1,64 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach } from 'mocha';
+import proxyquire from 'proxyquire';
+import sinon from 'sinon';
+
+const hasOfflineLicenseStub = sinon.stub();
+const getOldestStub = sinon.stub();
+const fetchStub = sinon.stub();
+const buildRegistrationDataStub = sinon.stub();
+
+const { registerPreIntentWorkspaceWizard } = proxyquire
+	.noCallThru()
+	.load('../../../../../server/lib/cloud/registerPreIntentWorkspaceWizard.ts', {
+		'@rocket.chat/license': { License: { hasOfflineLicense: hasOfflineLicenseStub } },
+		'@rocket.chat/models': { Users: { getOldest: getOldestStub } },
+		'@rocket.chat/server-fetch': { serverFetch: fetchStub },
+		'./buildRegistrationData': { buildWorkspaceRegistrationData: buildRegistrationDataStub },
+		'../../settings': { settings: { get: sinon.stub().returns('https://cloud.rocket.chat') } },
+		'../logger/system': { SystemLogger: { error: sinon.stub() } },
+	});
+
+describe('registerPreIntentWorkspaceWizard', () => {
+	beforeEach(() => {
+		hasOfflineLicenseStub.reset();
+		getOldestStub.reset();
+		fetchStub.reset();
+		buildRegistrationDataStub.reset();
+	});
+
+	it('should return false without querying users or fetching when the license is offline', async () => {
+		hasOfflineLicenseStub.returns(true);
+
+		const result = await registerPreIntentWorkspaceWizard();
+
+		expect(result).to.be.false;
+		expect(getOldestStub.called).to.be.false;
+		expect(fetchStub.called).to.be.false;
+	});
+
+	it('should not fetch when an offline license is applied while registration data is being built', async () => {
+		// entry check passes, dispatch-time re-check catches the license change mid-flight
+		hasOfflineLicenseStub.onFirstCall().returns(false);
+		hasOfflineLicenseStub.onSecondCall().returns(true);
+		getOldestStub.resolves({ emails: [{ address: 'admin@example.com' }] });
+		buildRegistrationDataStub.resolves({});
+
+		const result = await registerPreIntentWorkspaceWizard();
+
+		expect(result).to.be.false;
+		expect(fetchStub.called).to.be.false;
+	});
+
+	it('should contact the cloud when the license is not offline', async () => {
+		hasOfflineLicenseStub.returns(false);
+		getOldestStub.resolves({ emails: [{ address: 'admin@example.com' }] });
+		buildRegistrationDataStub.resolves({});
+		fetchStub.resolves({ ok: true });
+
+		const result = await registerPreIntentWorkspaceWizard();
+
+		expect(result).to.be.true;
+		expect(fetchStub.calledOnce).to.be.true;
+	});
+});

apps/meteor/tests/unit/server/lib/cloud/syncWorkspace/syncCloudData.spec.ts

@@ -0,0 +1,101 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach } from 'mocha';
+import proxyquire from 'proxyquire';
+import sinon from 'sinon';
+
+const models = {
+	Settings: { updateValueById: sinon.stub() },
+};
+
+const mockedFetchWorkspaceSyncPayload = sinon.stub();
+
+const { syncCloudData } = proxyquire.noCallThru().load('../../../../../../server/lib/cloud/syncWorkspace/syncCloudData.ts', {
+	'@rocket.chat/license': { DuplicatedLicenseError: sinon.stub() },
+	'@rocket.chat/models': models,
+	'../../callbacks': { callbacks: { run: sinon.stub() } },
+	'../../../../lib/errors/CloudWorkspaceAccessError': { CloudWorkspaceAccessError: sinon.stub() },
+	'../../../../lib/errors/CloudWorkspaceRegistrationError': { CloudWorkspaceRegistrationError: sinon.stub() },
+	'../../logger/system': { SystemLogger: { info: sinon.stub(), error: sinon.stub() } },
+	'../buildRegistrationData': { buildWorkspaceRegistrationData: sinon.stub().resolves({}) },
+	'../getWorkspaceAccessToken': {
+		getWorkspaceAccessToken: sinon.stub().resolves('token'),
+		CloudWorkspaceAccessTokenEmptyError: sinon.stub(),
+	},
+	'../retrieveRegistrationStatus': { retrieveRegistrationStatus: sinon.stub().resolves({ workspaceRegistered: true }) },
+	'./fetchWorkspaceSyncPayload': { fetchWorkspaceSyncPayload: mockedFetchWorkspaceSyncPayload },
+});
+
+describe('SyncCloudData', () => {
+	beforeEach(() => {
+		models.Settings.updateValueById.reset();
+		mockedFetchWorkspaceSyncPayload.reset();
+	});
+
+	it('should save cloudSyncAnnouncement payload on Cloud_Sync_Announcement_Payload setting when present', async () => {
+		const workspaceSyncPayloadResponse = {
+			workspaceId: 'workspaceId',
+			publicKey: 'publicKey',
+			license: {},
+			removeLicense: false,
+			cloudSyncAnnouncement: {
+				viewId: 'subscription-announcement',
+				appId: 'cloud-announcements-core',
+				blocks: [
+					{
+						type: 'callout',
+						title: {
+							type: 'plain_text',
+							text: 'Workspace eligible for Starter Plan',
+						},
+						text: {
+							type: 'plain_text',
+							text: 'Get free access to premium capabilities for up to 50 users',
+						},
+						accessory: {
+							type: 'button',
+							text: {
+								type: 'plain_text',
+								text: 'Switch Plan',
+							},
+							actionId: 'callout-action',
+							appId: 'cloud-announcements-core',
+							blockId: 'section-button',
+						},
+					},
+				],
+			},
+		};
+
+		mockedFetchWorkspaceSyncPayload.resolves(workspaceSyncPayloadResponse);
+
+		await syncCloudData();
+
+		expect(mockedFetchWorkspaceSyncPayload.calledOnce).to.be.true;
+
+		expect(
+			models.Settings.updateValueById.calledOnceWith(
+				'Cloud_Sync_Announcement_Payload',
+				JSON.stringify(workspaceSyncPayloadResponse.cloudSyncAnnouncement),
+			),
+		).to.be.true;
+	});
+
+	it("Should save as 'null' the setting update if cloudSyncAnnouncement is not present", async () => {
+		const workspaceSyncPayloadResponse = {
+			workspaceId: 'workspaceId',
+			publicKey: 'publicKey',
+			license: {},
+			removeLicense: false,
+		};
+
+		mockedFetchWorkspaceSyncPayload.resolves(workspaceSyncPayloadResponse);
+
+		await syncCloudData();
+
+		expect(mockedFetchWorkspaceSyncPayload.calledOnce).to.be.true;
+
+		expect(models.Settings.updateValueById.calledOnce).to.be.true;
+
+		expect(models.Settings.updateValueById.calledWith('Cloud_Sync_Announcement_Payload', 'null')).to.be.true;
+	});
+});

apps/meteor/tests/unit/server/lib/cloud/userLogout.spec.ts

@@ -0,0 +1,72 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach } from 'mocha';
+import proxyquire from 'proxyquire';
+import sinon from 'sinon';
+
+const hasOfflineLicenseStub = sinon.stub();
+const retrieveRegistrationStatusStub = sinon.stub();
+const userLoggedOutStub = sinon.stub();
+const fetchStub = sinon.stub();
+const findOneByIdStub = sinon.stub();
+const settingsGetStub = sinon.stub();
+
+const { userLogout } = proxyquire.noCallThru().load('../../../../../server/lib/cloud/userLogout.ts', {
+	'@rocket.chat/license': { License: { hasOfflineLicense: hasOfflineLicenseStub } },
+	'@rocket.chat/models': { Users: { findOneById: findOneByIdStub } },
+	'@rocket.chat/server-fetch': { serverFetch: fetchStub },
+	'./retrieveRegistrationStatus': { retrieveRegistrationStatus: retrieveRegistrationStatusStub },
+	'./userLoggedOut': { userLoggedOut: userLoggedOutStub },
+	'../../settings': { settings: { get: settingsGetStub } },
+	'../logger/system': { SystemLogger: { error: sinon.stub() } },
+});
+
+describe('userLogout', () => {
+	beforeEach(() => {
+		hasOfflineLicenseStub.reset();
+		retrieveRegistrationStatusStub.reset();
+		userLoggedOutStub.reset();
+		fetchStub.reset();
+		findOneByIdStub.reset();
+		settingsGetStub.reset();
+	});
+
+	it('should still destroy local cloud credentials on logout under an offline license, without calling the revocation endpoint', async () => {
+		retrieveRegistrationStatusStub.resolves({ workspaceRegistered: true });
+		hasOfflineLicenseStub.returns(true);
+		userLoggedOutStub.resolves(true);
+
+		const result = await userLogout('user-id');
+
+		expect(userLoggedOutStub.calledOnceWithExactly('user-id')).to.be.true;
+		expect(fetchStub.called).to.be.false;
+		expect(result).to.be.true;
+	});
+
+	it('should revoke the refresh token and destroy local cloud credentials when the license is not offline', async () => {
+		retrieveRegistrationStatusStub.resolves({ workspaceRegistered: true });
+		hasOfflineLicenseStub.returns(false);
+		findOneByIdStub.resolves({ _id: 'user-id', services: { cloud: { refreshToken: 'refresh-token' } } });
+		settingsGetStub.withArgs('Cloud_Workspace_Client_Id').returns('client-id');
+		settingsGetStub.withArgs('Cloud_Workspace_Client_Secret').returns('client-secret');
+		settingsGetStub.withArgs('Cloud_Url').returns('https://cloud.rocket.chat');
+		fetchStub.resolves({});
+		userLoggedOutStub.resolves(true);
+
+		const result = await userLogout('user-id');
+
+		expect(fetchStub.calledOnce).to.be.true;
+		expect(fetchStub.firstCall.args[0]).to.equal('https://cloud.rocket.chat/api/oauth/revoke');
+		expect(userLoggedOutStub.calledOnceWithExactly('user-id')).to.be.true;
+		expect(result).to.be.true;
+	});
+
+	it('should do nothing when the workspace is not registered', async () => {
+		retrieveRegistrationStatusStub.resolves({ workspaceRegistered: false });
+
+		const result = await userLogout('user-id');
+
+		expect(result).to.equal('');
+		expect(fetchStub.called).to.be.false;
+		expect(userLoggedOutStub.called).to.be.false;
+	});
+});