development/vscode
development/vscode
1
0
Fork 0
mirror of https://github.com/Microsoft/vscode synced 2024-10-12 06:17:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Extract isWorkspaceTrustEnabled into a function (#121385)

Browse source
This commit is contained in:
Ladislau Szomoru 2021-04-15 14:39:48 +02:00 committed by GitHub
parent 91f8c81acb
commit d13686a860
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 31 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/vs/platform/workspace/common/workspaceTrust.ts
View file

@ -57,7 +57,6 @@ export interface IWorkspaceTrustManagementService {
onDidChangeTrust: WorkspaceTrustChangeEvent;
isWorkpaceTrusted(): boolean;
setWorkspaceTrust(trusted: boolean): void;
isWorkspaceTrustEnabled(): boolean;
}
export const IWorkspaceTrustRequestService = createDecorator<IWorkspaceTrustRequestService>('workspaceTrustRequestService');

7
src/vs/workbench/contrib/extensions/browser/extensionsActions.ts
View file

@ -59,8 +59,8 @@ import { IContextMenuProvider } from 'vs/base/browser/contextmenu';
import { ILogService } from 'vs/platform/log/common/log';
import * as Constants from 'vs/workbench/contrib/logs/common/logConstants';
import { infoIcon, manageExtensionIcon, syncEnabledIcon, syncIgnoredIcon, trustIcon, warningIcon } from 'vs/workbench/contrib/extensions/browser/extensionsIcons';
import { IWorkspaceTrustManagementService } from 'vs/platform/workspace/common/workspaceTrust';
import { isWeb } from 'vs/base/common/platform';
import { isWorkspaceTrustEnabled } from 'vs/workbench/services/workspaces/common/workspaceTrust';
function getRelativeDateLabel(date: Date): string {
const delta = new Date().getTime() - date.getTime();
@ -2093,8 +2093,7 @@ export class SystemDisabledWarningAction extends ExtensionAction {
@IExtensionsWorkbenchService private readonly extensionsWorkbenchService: IExtensionsWorkbenchService,
@IExtensionService private readonly extensionService: IExtensionService,
@IProductService productService: IProductService,
@IConfigurationService configurationService: IConfigurationService,
@IWorkspaceTrustManagementService private readonly workspaceTrustManagementService: IWorkspaceTrustManagementService
@IConfigurationService private readonly configurationService: IConfigurationService
) {
super('extensions.install', '', `${SystemDisabledWarningAction.CLASS} hide`, false);
this._register(this.labelService.onDidChangeFormatters(() => this.update(), this));
@ -2162,7 +2161,7 @@ export class SystemDisabledWarningAction extends ExtensionAction {
return;
}
}
if (this.workspaceTrustManagementService.isWorkspaceTrustEnabled() && this.extension.enablementState === EnablementState.DisabledByTrustRequirement) {
if (isWorkspaceTrustEnabled(this.configurationService) && this.extension.enablementState === EnablementState.DisabledByTrustRequirement) {
this.class = `${SystemDisabledWarningAction.TRUST_CLASS}`;
this.tooltip = localize('extension disabled because of trust requirement', "This extension has been disabled because the current workspace is not trusted");
return;

13
src/vs/workbench/contrib/workspace/browser/workspace.contribution.ts
View file

@ -27,7 +27,7 @@ import { IStatusbarEntry, IStatusbarEntryAccessor, IStatusbarService, StatusbarA
import { IEditorRegistry, Extensions as EditorExtensions, EditorDescriptor } from 'vs/workbench/browser/editor';
import { WorkspaceTrustEditor } from 'vs/workbench/contrib/workspace/browser/workspaceTrustEditor';
import { WorkspaceTrustEditorInput } from 'vs/workbench/services/workspaces/browser/workspaceTrustEditorInput';
import { WorkspaceTrustContext, WORKSPACE_TRUST_ENABLED, WORKSPACE_TRUST_EXTENSION_REQUEST } from 'vs/workbench/services/workspaces/common/workspaceTrust';
import { isWorkspaceTrustEnabled, WorkspaceTrustContext, WORKSPACE_TRUST_ENABLED, WORKSPACE_TRUST_EXTENSION_REQUEST } from 'vs/workbench/services/workspaces/common/workspaceTrust';
import { EditorInput, Extensions as EditorInputExtensions, IEditorInputSerializer, IEditorInputFactoryRegistry } from 'vs/workbench/common/editor';
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
@ -36,6 +36,7 @@ import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storag
import { isWeb } from 'vs/base/common/platform';
import { IsWebContext } from 'vs/platform/contextkey/common/contextkeys';
import { dirname, resolve } from 'vs/base/common/path';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
const workspaceTrustIcon = registerIcon('workspace-trust-icon', Codicon.shield, localize('workspaceTrustIcon', "Icon for workspace trust badge."));
@ -157,6 +158,7 @@ class WorkspaceTrustStatusbarItem extends Disposable implements IWorkbenchContri
private contextKeys = new Set([this.pendingRequestContextKey]);
constructor(
@IConfigurationService configurationService: IConfigurationService,
@IStatusbarService private readonly statusbarService: IStatusbarService,
@IWorkspaceTrustManagementService private readonly workspaceTrustManagementService: IWorkspaceTrustManagementService,
@IContextKeyService private readonly contextKeyService: IContextKeyService
@ -165,7 +167,7 @@ class WorkspaceTrustStatusbarItem extends Disposable implements IWorkbenchContri
this.statusBarEntryAccessor = this._register(new MutableDisposable<IStatusbarEntryAccessor>());
if (this.workspaceTrustManagementService.isWorkspaceTrustEnabled()) {
if (isWorkspaceTrustEnabled(configurationService)) {
const entry = this.getStatusbarEntry(this.workspaceTrustManagementService.isWorkpaceTrusted());
this.statusBarEntryAccessor.value = this.statusbarService.addEntry(entry, WorkspaceTrustStatusbarItem.ID, localize('status.WorkspaceTrust', "Workspace Trust"), StatusbarAlignment.LEFT, 0.99 * Number.MAX_VALUE /* Right of remote indicator */);
this._register(this.workspaceTrustManagementService.onDidChangeTrust(trusted => this.updateStatusbarEntry(trusted)));
@ -336,6 +338,7 @@ Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration)
*/
class WorkspaceTrustTelemetryContribution extends Disposable implements IWorkbenchContribution {
constructor(
@IConfigurationService private readonly configurationService: IConfigurationService,
@IExtensionService private readonly extensionService: IExtensionService,
@ITelemetryService private readonly telemetryService: ITelemetryService,
@IWorkspaceContextService private readonly workspaceContextService: IWorkspaceContextService,
@ -352,7 +355,7 @@ class WorkspaceTrustTelemetryContribution extends Disposable implements IWorkben
}
private logInitialWorkspaceTrustInfo(): void {
if (!this.workspaceTrustManagementService.isWorkspaceTrustEnabled()) {
if (!isWorkspaceTrustEnabled(this.configurationService)) {
return;
}
@ -374,7 +377,7 @@ class WorkspaceTrustTelemetryContribution extends Disposable implements IWorkben
}
private logWorkspaceTrustChangeEvent(isTrusted: boolean): void {
if (!this.workspaceTrustManagementService.isWorkspaceTrustEnabled()) {
if (!isWorkspaceTrustEnabled(this.configurationService)) {
return;
}
@ -434,7 +437,7 @@ class WorkspaceTrustTelemetryContribution extends Disposable implements IWorkben
}
private async logWorkspaceTrustRequest(options: WorkspaceTrustRequestOptions): Promise<void> {
if (!this.workspaceTrustManagementService.isWorkspaceTrustEnabled()) {
if (!isWorkspaceTrustEnabled(this.configurationService)) {
return;
}

8
src/vs/workbench/services/extensions/common/extensionWorkspaceTrustRequest.ts
View file

@ -11,8 +11,7 @@ import { ExtensionIdentifier, ExtensionWorkspaceTrustRequestType, IExtensionMani
import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IProductService } from 'vs/platform/product/common/productService';
import { IWorkspaceTrustManagementService } from 'vs/platform/workspace/common/workspaceTrust';
import { WORKSPACE_TRUST_EXTENSION_REQUEST } from 'vs/workbench/services/workspaces/common/workspaceTrust';
import { isWorkspaceTrustEnabled, WORKSPACE_TRUST_EXTENSION_REQUEST } from 'vs/workbench/services/workspaces/common/workspaceTrust';
export const IExtensionWorkspaceTrustRequestService = createDecorator<IExtensionWorkspaceTrustRequestService>('extensionWorkspaceTrustRequestService');
@ -30,8 +29,7 @@ export class ExtensionWorkspaceTrustRequestService extends Disposable implements
constructor(
@IProductService productService: IProductService,
@IConfigurationService configurationService: IConfigurationService,
@IWorkspaceTrustManagementService private readonly _workspaceTrustManagementService: IWorkspaceTrustManagementService
@IConfigurationService private readonly configurationService: IConfigurationService
) {
super();
@ -69,7 +67,7 @@ export class ExtensionWorkspaceTrustRequestService extends Disposable implements
getExtensionWorkspaceTrustRequestType(manifest: IExtensionManifest): ExtensionWorkspaceTrustRequestType {
// Workspace trust feature is disabled, or extension has no entry point
if (!this._workspaceTrustManagementService.isWorkspaceTrustEnabled() || !manifest.main) {
if (!isWorkspaceTrustEnabled(this.configurationService) || !manifest.main) {
return 'never';
}

33
src/vs/workbench/services/extensions/test/common/extensionWorkspaceTrustRequest.test.ts
View file

@ -4,12 +4,9 @@
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { mock } from 'vs/base/test/common/mock';
import { IWorkspaceTrustManagementService } from 'vs/platform/workspace/common/workspaceTrust';
import { ExtensionWorkspaceTrustRequestService } from 'vs/workbench/services/extensions/common/extensionWorkspaceTrustRequest';
import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService';
import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
import { WorkspaceTrustManagementService } from 'vs/workbench/services/workspaces/common/workspaceTrust';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { IProductService } from 'vs/platform/product/common/productService';
import { ExtensionWorkspaceTrustRequestType, IExtensionManifest } from 'vs/platform/extensions/common/extensions';
@ -20,11 +17,12 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
let instantiationService: TestInstantiationService;
let testConfigurationService: TestConfigurationService;
setup(() => {
setup(async () => {
instantiationService = new TestInstantiationService();
testConfigurationService = new TestConfigurationService();
instantiationService.stub(IConfigurationService, testConfigurationService);
await testConfigurationService.setUserConfiguration('security', { workspace: { trust: { enabled: true } } });
});
teardown(() => testObject.dispose());
@ -38,15 +36,14 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
test('test extension workspace trust request when main entry point is missing', () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{});
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
const extensionMaifest = getExtensionManifest();
assertWorkspaceTrustRequest(extensionMaifest, 'never');
});
test('test extension workspace trust request when workspace trust is disabled', () => {
test('test extension workspace trust request when workspace trust is disabled', async () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{});
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(false));
await testConfigurationService.setUserConfiguration('security', { workspace: { trust: { enabled: false } } });
const extensionMaifest = getExtensionManifest({ main: './out/extension.js' });
assertWorkspaceTrustRequest(extensionMaifest, 'never');
@ -54,7 +51,6 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
test('test extension workspace trust request when override exists in settings.json', async () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{});
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
await testConfigurationService.setUserConfiguration('security', { workspace: { trust: { extensionRequest: { 'pub.a': { request: 'never' } } } } });
const extensionMaifest = getExtensionManifest({ main: './out/extension.js', workspaceTrust: { request: 'onDemand' } });
@ -63,7 +59,6 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
test('test extension workspace trust request when override for the version exists in settings.json', async () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{});
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
await testConfigurationService.setUserConfiguration('security', { workspace: { trust: { extensionRequest: { 'pub.a': { request: 'never', version: '1.0.0' } } } } });
const extensionMaifest = getExtensionManifest({ main: './out/extension.js', workspaceTrust: { request: 'onDemand' } });
@ -72,16 +67,21 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
test('test extension workspace trust request when override for a different version exists in settings.json', async () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{});
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
await testConfigurationService.setUserConfiguration('security', { workspace: { trust: { extensionRequest: { 'pub.a': { request: 'never', version: '2.0.0' } } } } });
await testConfigurationService.setUserConfiguration('security', {
workspace: {
trust: {
enabled: true,
extensionRequest: { 'pub.a': { request: 'never', version: '2.0.0' } }
}
}
});
const extensionMaifest = getExtensionManifest({ main: './out/extension.js', workspaceTrust: { request: 'onDemand' } });
assertWorkspaceTrustRequest(extensionMaifest, 'onDemand');
});
test('test extension workspace trust request when default exists in product.json', () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{ extensionWorkspaceTrustRequest: { 'pub.a': { default: 'never' } } });
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
const extensionMaifest = getExtensionManifest({ main: './out/extension.js' });
assertWorkspaceTrustRequest(extensionMaifest, 'never');
@ -89,7 +89,6 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
test('test extension workspace trust request when override exists in product.json', () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{ extensionWorkspaceTrustRequest: { 'pub.a': { override: 'onDemand' } } });
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
const extensionMaifest = getExtensionManifest({ main: './out/extension.js', workspaceTrust: { request: 'never' } });
assertWorkspaceTrustRequest(extensionMaifest, 'onDemand');
@ -97,7 +96,6 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
test('test extension workspace trust request when value exists in package.json', () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{});
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
const extensionMaifest = getExtensionManifest({ main: './out/extension.js', workspaceTrust: { request: 'onDemand' } });
assertWorkspaceTrustRequest(extensionMaifest, 'onDemand');
@ -105,7 +103,6 @@ suite('ExtensionWorkspaceTrustRequestService', () => {
test('test extension workspace trust request when no value exists in package.json', () => {
instantiationService.stub(IProductService, <Partial<IProductService>>{});
instantiationService.stub(IWorkspaceTrustManagementService, getWorkspaceTrustManagementService(true));
const extensionMaifest = getExtensionManifest({ main: './out/extension.js' });
assertWorkspaceTrustRequest(extensionMaifest, 'onStart');
@ -120,9 +117,3 @@ function getExtensionManifest(properties: any = {}): IExtensionManifest {
...properties
}) as IExtensionManifest;
}
function getWorkspaceTrustManagementService(isEnabled: boolean): WorkspaceTrustManagementService {
return new class extends mock<WorkspaceTrustManagementService>() {
override isWorkspaceTrustEnabled() { return isEnabled; }
};
}

10
src/vs/workbench/services/workspaces/common/workspaceTrust.ts
View file

@ -23,6 +23,10 @@ export const WorkspaceTrustContext = {
IsTrusted: new RawContextKey<boolean>('isWorkspaceTrusted', false)
};
export function isWorkspaceTrustEnabled(configurationService: IConfigurationService): boolean {
return configurationService.inspect<boolean>(WORKSPACE_TRUST_ENABLED).userValue ?? false;
}
export class WorkspaceTrustStorageService extends Disposable implements IWorkspaceTrustStorageService {
_serviceBrand: undefined;
@ -185,7 +189,7 @@ export class WorkspaceTrustManagementService extends Disposable implements IWork
}
private calculateWorkspaceTrust(): boolean {
if (!this.isWorkspaceTrustEnabled()) {
if (!isWorkspaceTrustEnabled(this.configurationService)) {
return true;
}
@ -207,10 +211,6 @@ export class WorkspaceTrustManagementService extends Disposable implements IWork
const folderURIs = this.workspaceService.getWorkspace().folders.map(f => f.uri);
this.workspaceTrustStorageService.setFoldersTrust(folderURIs, trusted);
}
isWorkspaceTrustEnabled(): boolean {
return this.configurationService.inspect<boolean>(WORKSPACE_TRUST_ENABLED).userValue ?? false;
}
}
export class WorkspaceTrustRequestService extends Disposable implements IWorkspaceTrustRequestService {

8
src/vs/workbench/services/workspaces/test/common/testWorkspaceTrustService.ts
View file

@ -49,14 +49,6 @@ export class TestWorkspaceTrustManagementService implements IWorkspaceTrustManag
setWorkspaceTrust(trusted: boolean): void {
throw new Error('Method not implemented.');
}
isWorkspaceTrustEnabled(): boolean {
return true;
}
requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined> {
return Promise.resolve(true);
}
}
export class TestWorkspaceTrustRequestService implements IWorkspaceTrustRequestService {