@theia/workspace 1.70.0-next.7 → 1.70.0-next.71

package/src/browser/workspace-trust-service.spec.ts

@@ -51,6 +51,10 @@ class TestableWorkspaceTrustService extends WorkspaceTrustService {
     public async testCalculateWorkspaceTrust(): Promise<boolean | undefined> {
         return this.calculateWorkspaceTrust();
     }
+
+    public testShouldReloadForTrustChange(newTrust: boolean): boolean {
+        return this.shouldReloadForTrustChange(newTrust);
+    }
 }
 
 describe('WorkspaceTrustService', () => {
@@ -310,7 +314,7 @@ describe('WorkspaceTrustService', () => {
 
         beforeEach(() => {
             areAllWorkspaceUrisTrustedStub = sinon.stub(service as unknown as { areAllWorkspaceUrisTrusted: () => Promise<boolean> }, 'areAllWorkspaceUrisTrusted');
-            setWorkspaceTrustStub = sinon.stub(service, 'setWorkspaceTrust');
+            setWorkspaceTrustStub = sinon.stub(service, 'setWorkspaceTrust').resolves();
             isEmptyWorkspaceStub = sinon.stub(service as unknown as { isEmptyWorkspace: () => Promise<boolean> }, 'isEmptyWorkspace');
             // Mock workspaceTrustPref - default emptyWindow to false so trusted folders logic runs
             workspaceTrustPrefStub = { [WORKSPACE_TRUST_EMPTY_WINDOW]: false };
@@ -386,7 +390,7 @@ describe('WorkspaceTrustService', () => {
 
                 await service.testHandlePreferenceChange(change);
 
-                expect(setWorkspaceTrustStub.calledOnceWith(true)).to.be.true;
+                expect(setWorkspaceTrustStub.calledOnceWith(true, false)).to.be.true;
             });
 
             it('should update trust to false when emptyWindow setting changes to false for empty window', async () => {
@@ -401,7 +405,7 @@ describe('WorkspaceTrustService', () => {
 
                 await service.testHandlePreferenceChange(change);
 
-                expect(setWorkspaceTrustStub.calledOnceWith(false)).to.be.true;
+                expect(setWorkspaceTrustStub.calledOnceWith(false, false)).to.be.true;
             });
 
             it('should not update trust when emptyWindow setting changes but workspace has roots', async () => {
@@ -437,6 +441,59 @@ describe('WorkspaceTrustService', () => {
             });
         });
 
+        describe('workspaceTrustEnabled setting changes', () => {
+            let windowServiceStub: { reload: sinon.SinonStub; setSafeToShutDown: sinon.SinonStub };
+            let confirmRestartStub: sinon.SinonStub;
+
+            beforeEach(() => {
+                windowServiceStub = { reload: sinon.stub(), setSafeToShutDown: sinon.stub() };
+                (service as unknown as { windowService: typeof windowServiceStub }).windowService = windowServiceStub;
+                confirmRestartStub = sinon.stub(
+                    service as unknown as { confirmRestart: () => Promise<boolean> },
+                    'confirmRestart'
+                );
+                sinon.stub(
+                    service as unknown as { resolveWorkspaceTrust: () => Promise<void> },
+                    'resolveWorkspaceTrust'
+                ).resolves();
+                // Stub isWorkspaceTrustResolved to return true (simulates resolved state)
+                sinon.stub(service, 'isWorkspaceTrustResolved').returns(true);
+                service.setCurrentTrust(true);
+            });
+
+            it('should reload without setSafeToShutDown when user confirms restart', async () => {
+                confirmRestartStub.resolves(true);
+
+                const change: PreferenceChange = {
+                    preferenceName: WORKSPACE_TRUST_ENABLED,
+                    scope: PreferenceScope.User,
+                    domain: [],
+                    affects: () => true
+                };
+
+                await service.testHandlePreferenceChange(change);
+
+                expect(windowServiceStub.reload.calledOnce).to.be.true;
+                expect(windowServiceStub.setSafeToShutDown.called).to.be.false;
+            });
+
+            it('should not reload when user cancels restart', async () => {
+                confirmRestartStub.resolves(false);
+
+                const change: PreferenceChange = {
+                    preferenceName: WORKSPACE_TRUST_ENABLED,
+                    scope: PreferenceScope.User,
+                    domain: [],
+                    affects: () => true
+                };
+
+                await service.testHandlePreferenceChange(change);
+
+                expect(windowServiceStub.reload.called).to.be.false;
+                expect(windowServiceStub.setSafeToShutDown.called).to.be.false;
+            });
+        });
+
         describe('trustedFolders change for empty window with emptyWindow enabled', () => {
             beforeEach(() => {
                 isEmptyWorkspaceStub.resolves(true);
@@ -459,4 +516,239 @@ describe('WorkspaceTrustService', () => {
             });
         });
     });
+
+    describe('setWorkspaceTrust and trust change handling', () => {
+        let storeWorkspaceTrustStub: sinon.SinonStub;
+        let addToTrustedFoldersStub: sinon.SinonStub;
+        let removeFromTrustedFoldersStub: sinon.SinonStub;
+        let shouldReloadStub: sinon.SinonStub;
+        let windowServiceStub: { reload: sinon.SinonStub; setSafeToShutDown: sinon.SinonStub };
+        let contextKeyServiceStub: { setContext: sinon.SinonStub };
+        let onDidChangeEmitterStub: { fire: sinon.SinonStub };
+        let confirmRestartStub: sinon.SinonStub;
+
+        beforeEach(() => {
+            storeWorkspaceTrustStub = sinon.stub(
+                service as unknown as { storeWorkspaceTrust: (trust: boolean) => Promise<void> },
+                'storeWorkspaceTrust'
+            ).resolves();
+            addToTrustedFoldersStub = sinon.stub(service, 'addToTrustedFolders').resolves();
+            removeFromTrustedFoldersStub = sinon.stub(service, 'removeFromTrustedFolders').resolves();
+            shouldReloadStub = sinon.stub(
+                service as unknown as { shouldReloadForTrustChange: () => boolean },
+                'shouldReloadForTrustChange'
+            );
+            confirmRestartStub = sinon.stub(
+                service as unknown as { confirmRestart: () => Promise<boolean> },
+                'confirmRestart'
+            ).resolves(true);
+            windowServiceStub = { reload: sinon.stub(), setSafeToShutDown: sinon.stub() };
+            (service as unknown as { windowService: typeof windowServiceStub }).windowService = windowServiceStub;
+            contextKeyServiceStub = { setContext: sinon.stub() };
+            (service as unknown as { contextKeyService: typeof contextKeyServiceStub }).contextKeyService = contextKeyServiceStub;
+            onDidChangeEmitterStub = { fire: sinon.stub() };
+            (service as unknown as { onDidChangeWorkspaceTrustEmitter: typeof onDidChangeEmitterStub }).onDidChangeWorkspaceTrustEmitter = onDidChangeEmitterStub;
+        });
+
+        it('should update currentTrust and fire event', async () => {
+            service.setCurrentTrust(false);
+            shouldReloadStub.returns(false);
+
+            await service.setWorkspaceTrust(true);
+
+            expect(service.getCurrentTrust()).to.equal(true);
+            expect(contextKeyServiceStub.setContext.calledWith('isWorkspaceTrusted', true)).to.be.true;
+            expect(onDidChangeEmitterStub.fire.calledWith(true)).to.be.true;
+        });
+
+        it('should be a no-op when trust value does not change', async () => {
+            service.setCurrentTrust(true);
+
+            await service.setWorkspaceTrust(true);
+
+            expect(contextKeyServiceStub.setContext.called).to.be.false;
+            expect(onDidChangeEmitterStub.fire.called).to.be.false;
+            expect(storeWorkspaceTrustStub.called).to.be.false;
+        });
+
+        it('should confirm restart before storing or firing events when reload is required', async () => {
+            const callOrder: string[] = [];
+            confirmRestartStub.callsFake(async () => {
+                callOrder.push('confirm');
+                return true;
+            });
+            storeWorkspaceTrustStub.callsFake(() => {
+                callOrder.push('store');
+                return Promise.resolve();
+            });
+            onDidChangeEmitterStub.fire.callsFake(() => {
+                callOrder.push('fire');
+            });
+            shouldReloadStub.returns(true);
+
+            service.setCurrentTrust(false);
+            await service.setWorkspaceTrust(true);
+
+            expect(callOrder[0]).to.equal('confirm');
+            expect(callOrder).to.include('store');
+            expect(callOrder).to.include('fire');
+        });
+
+        it('should call windowService.reload() when shouldReloadForTrustChange returns true', async () => {
+            shouldReloadStub.returns(true);
+
+            service.setCurrentTrust(false);
+            await service.setWorkspaceTrust(true);
+
+            expect(windowServiceStub.reload.calledOnce).to.be.true;
+        });
+
+        it('should NOT call windowService.reload() when shouldReloadForTrustChange returns false', async () => {
+            shouldReloadStub.returns(false);
+
+            service.setCurrentTrust(false);
+            await service.setWorkspaceTrust(true);
+
+            expect(windowServiceStub.reload.called).to.be.false;
+        });
+
+        it('should NOT call setSafeToShutDown (unsaved-changes protection preserved)', async () => {
+            shouldReloadStub.returns(true);
+
+            service.setCurrentTrust(false);
+            await service.setWorkspaceTrust(true);
+
+            expect(windowServiceStub.setSafeToShutDown.called).to.be.false;
+        });
+
+        it('should NOT call windowService.reload() when user cancels confirm dialog', async () => {
+            shouldReloadStub.returns(true);
+            confirmRestartStub.resolves(false);
+
+            service.setCurrentTrust(false);
+            await service.setWorkspaceTrust(true);
+
+            expect(windowServiceStub.reload.called).to.be.false;
+        });
+
+        it('should leave trust state unchanged and not fire events when user cancels the restart dialog', async () => {
+            shouldReloadStub.returns(true);
+            confirmRestartStub.resolves(false);
+
+            service.setCurrentTrust(false);
+            await service.setWorkspaceTrust(true);
+
+            expect(service.getCurrentTrust()).to.equal(false);
+            expect(contextKeyServiceStub.setContext.called).to.be.false;
+            expect(onDidChangeEmitterStub.fire.called).to.be.false;
+            expect(storeWorkspaceTrustStub.called).to.be.false;
+            expect(addToTrustedFoldersStub.called).to.be.false;
+            expect(removeFromTrustedFoldersStub.called).to.be.false;
+        });
+
+        it('should call addToTrustedFolders when setting trusted=true', async () => {
+            shouldReloadStub.returns(false);
+            service.setCurrentTrust(false);
+
+            await service.setWorkspaceTrust(true);
+
+            expect(addToTrustedFoldersStub.calledOnce).to.be.true;
+            expect(removeFromTrustedFoldersStub.called).to.be.false;
+        });
+
+        it('should call removeFromTrustedFolders when setting trusted=false', async () => {
+            shouldReloadStub.returns(false);
+            service.setCurrentTrust(true);
+
+            await service.setWorkspaceTrust(false);
+
+            expect(removeFromTrustedFoldersStub.calledOnce).to.be.true;
+            expect(addToTrustedFoldersStub.called).to.be.false;
+        });
+
+        it('should NOT reload when reload=false even if shouldReloadForTrustChange returns true', async () => {
+            shouldReloadStub.returns(true);
+
+            service.setCurrentTrust(false);
+            await service.setWorkspaceTrust(true, false);
+
+            expect(windowServiceStub.reload.called).to.be.false;
+        });
+
+        it('should still update state and fire event when reload=false', async () => {
+            service.setCurrentTrust(false);
+            shouldReloadStub.returns(true);
+
+            await service.setWorkspaceTrust(true, false);
+
+            expect(service.getCurrentTrust()).to.equal(true);
+            expect(contextKeyServiceStub.setContext.calledWith('isWorkspaceTrusted', true)).to.be.true;
+            expect(onDidChangeEmitterStub.fire.calledWith(true)).to.be.true;
+        });
+
+    });
+
+    describe('shouldReloadForTrustChange', () => {
+        let freshService: TestableWorkspaceTrustService;
+
+        beforeEach(() => {
+            freshService = new TestableWorkspaceTrustService();
+        });
+
+        it('should return false when no restriction contributions are registered', () => {
+            (freshService as unknown as { restrictionContributions: { getContributions: () => unknown[] } })
+                .restrictionContributions = { getContributions: () => [] };
+
+            expect(freshService.testShouldReloadForTrustChange(true)).to.be.false;
+        });
+
+        it('should return false when contribution does not implement requiresReloadOnTrustChange', () => {
+            (freshService as unknown as { restrictionContributions: { getContributions: () => unknown[] } })
+                .restrictionContributions = { getContributions: () => [{ getRestrictions: () => [] }] };
+
+            expect(freshService.testShouldReloadForTrustChange(true)).to.be.false;
+        });
+
+        it('should return true when a contribution requires reload for the given trust value', () => {
+            (freshService as unknown as { restrictionContributions: { getContributions: () => unknown[] } })
+                .restrictionContributions = {
+                getContributions: () => [{
+                    getRestrictions: () => [],
+                    requiresReloadOnTrustChange: (_newTrust: boolean) => true
+                }]
+            };
+
+            expect(freshService.testShouldReloadForTrustChange(true)).to.be.true;
+        });
+
+        it('should return false when contribution returns false for requiresReloadOnTrustChange', () => {
+            (freshService as unknown as { restrictionContributions: { getContributions: () => unknown[] } })
+                .restrictionContributions = {
+                getContributions: () => [{
+                    getRestrictions: () => [],
+                    requiresReloadOnTrustChange: (_newTrust: boolean) => false
+                }]
+            };
+
+            expect(freshService.testShouldReloadForTrustChange(true)).to.be.false;
+        });
+
+        it('should pass newTrust value to requiresReloadOnTrustChange', () => {
+            const calls: boolean[] = [];
+            (freshService as unknown as { restrictionContributions: { getContributions: () => unknown[] } })
+                .restrictionContributions = {
+                getContributions: () => [{
+                    getRestrictions: () => [],
+                    requiresReloadOnTrustChange: (newTrust: boolean) => { calls.push(newTrust); return false; }
+                }]
+            };
+
+            freshService.testShouldReloadForTrustChange(false);
+            expect(calls).to.deep.equal([false]);
+
+            freshService.testShouldReloadForTrustChange(true);
+            expect(calls).to.deep.equal([false, true]);
+        });
+    });
+
 });

package/src/browser/workspace-trust-service.ts

@@ -51,6 +51,14 @@ export interface WorkspaceRestrictionContribution {
      * Called when building the restricted mode status bar tooltip.
      */
     getRestrictions(): WorkspaceRestriction[];
+
+    /**
+     * Returns whether a window reload is required when workspace trust changes to `newTrust`.
+     * Called before reloading on trust change to avoid unnecessary reloads when no
+     * trust-restricted items are actually affected.
+     * If not implemented, the contribution is assumed not to require a reload.
+     */
+    requiresReloadOnTrustChange?(newTrust: boolean): boolean;
 }
 
 export interface WorkspaceRestriction {
@@ -166,16 +174,28 @@ export class WorkspaceTrustService {
         }
     }
 
-    setWorkspaceTrust(trusted: boolean): void {
+    async setWorkspaceTrust(trusted: boolean, reload = true): Promise<void> {
         if (this.currentTrust === trusted) {
             return;
         }
+        const needsReload = reload && this.shouldReloadForTrustChange(trusted);
+        if (needsReload && !await this.confirmRestart()) {
+            return;
+        }
+        // Must be set before add/removeFromTrustedFolders to prevent handlePreferenceChange from recursing.
         this.currentTrust = trusted;
         this.contextKeyService.setContext('isWorkspaceTrusted', trusted);
-        if (this.workspaceTrustPref[WORKSPACE_TRUST_STARTUP_PROMPT] === WorkspaceTrustPrompt.ONCE) {
-            this.storeWorkspaceTrust(trusted);
-        }
         this.onDidChangeWorkspaceTrustEmitter.fire(trusted);
+        await this.storeWorkspaceTrust(trusted);
+        await (trusted ? this.addToTrustedFolders() : this.removeFromTrustedFolders());
+        if (needsReload) {
+            this.windowService.reload();
+        }
+    }
+
+    protected shouldReloadForTrustChange(newTrust: boolean): boolean {
+        return this.restrictionContributions.getContributions()
+            .some(c => c.requiresReloadOnTrustChange?.(newTrust) ?? false);
     }
 
     protected isWorkspaceTrustResolved(): boolean {
@@ -385,7 +405,7 @@ export class WorkspaceTrustService {
             }
             const areAllUrisTrusted = await this.areAllWorkspaceUrisTrusted();
             if (areAllUrisTrusted !== this.currentTrust) {
-                this.setWorkspaceTrust(areAllUrisTrusted);
+                await this.setWorkspaceTrust(areAllUrisTrusted);
             }
             return;
         }
@@ -397,7 +417,6 @@ export class WorkspaceTrustService {
 
             if (change.preferenceName === WORKSPACE_TRUST_ENABLED) {
                 if (!await this.isEmptyWorkspace() && this.isWorkspaceTrustResolved() && await this.confirmRestart()) {
-                    this.windowService.setSafeToShutDown();
                     this.windowService.reload();
                 }
                 this.resolveWorkspaceTrust();
@@ -408,7 +427,9 @@ export class WorkspaceTrustService {
                 // For empty windows, directly update trust based on the new setting value
                 const shouldTrust = !!this.workspaceTrustPref[WORKSPACE_TRUST_EMPTY_WINDOW];
                 if (this.currentTrust !== shouldTrust) {
-                    this.setWorkspaceTrust(shouldTrust);
+                    // No reload needed: in an empty window there are no workspace folders,
+                    // so no extensions are blocked by trust and no extension host restart is required.
+                    await this.setWorkspaceTrust(shouldTrust, false);
                 }
             }
         }
@@ -536,9 +557,7 @@ export class WorkspaceTrustService {
         try {
             const grantedTrust = await this.showTrustPromptDialog();
             if (grantedTrust) {
-                // User granted trust - update the state
-                this.setWorkspaceTrust(true);
-                await this.addToTrustedFolders();
+                await this.setWorkspaceTrust(true);
             }
             this.pendingTrustRequest.resolve(grantedTrust);
             return grantedTrust;