CoCalc -- mainThreadConfiguration.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/api/test/browser/mainThreadConfiguration.test.ts
³²⁹⁶ views
1
/*---------------------------------------------------------------------------------------------
2
 *  Copyright (c) Microsoft Corporation. All rights reserved.
3
 *  Licensed under the MIT License. See License.txt in the project root for license information.
4
 *--------------------------------------------------------------------------------------------*/
5

6
import assert from 'assert';
7
import * as sinon from 'sinon';
8
import { URI } from '../../../../base/common/uri.js';
9
import { Registry } from '../../../../platform/registry/common/platform.js';
10
import { Extensions, IConfigurationRegistry, ConfigurationScope } from '../../../../platform/configuration/common/configurationRegistry.js';
11
import { IWorkspaceContextService, WorkbenchState } from '../../../../platform/workspace/common/workspace.js';
12
import { TestInstantiationService } from '../../../../platform/instantiation/test/common/instantiationServiceMock.js';
13
import { MainThreadConfiguration } from '../../browser/mainThreadConfiguration.js';
14
import { SingleProxyRPCProtocol } from '../common/testRPCProtocol.js';
15
import { IConfigurationService, ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
16
import { WorkspaceService } from '../../../services/configuration/browser/configurationService.js';
17
import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
18
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
19

20
suite('MainThreadConfiguration', function () {
21

22
	ensureNoDisposablesAreLeakedInTestSuite();
23

24
	const proxy = {
25
		$initializeConfiguration: () => { }
26
	};
27
	let instantiationService: TestInstantiationService;
28
	let target: sinon.SinonSpy;
29

30
	suiteSetup(() => {
31
		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
32
			'id': 'extHostConfiguration',
33
			'title': 'a',
34
			'type': 'object',
35
			'properties': {
36
				'extHostConfiguration.resource': {
37
					'description': 'extHostConfiguration.resource',
38
					'type': 'boolean',
39
					'default': true,
40
					'scope': ConfigurationScope.RESOURCE
41
				},
42
				'extHostConfiguration.window': {
43
					'description': 'extHostConfiguration.resource',
44
					'type': 'boolean',
45
					'default': true,
46
					'scope': ConfigurationScope.WINDOW
47
				}
48
			}
49
		});
50
	});
51

52
	setup(() => {
53
		target = sinon.spy();
54

55
		instantiationService = new TestInstantiationService();
56
		instantiationService.stub(IConfigurationService, WorkspaceService);
57
		instantiationService.stub(IConfigurationService, 'onDidUpdateConfiguration', sinon.mock());
58
		instantiationService.stub(IConfigurationService, 'onDidChangeConfiguration', sinon.mock());
59
		instantiationService.stub(IConfigurationService, 'updateValue', target);
60
		instantiationService.stub(IEnvironmentService, {
61
			isBuilt: false
62
		});
63
	});
64

65
	teardown(() => {
66
		instantiationService.dispose();
67
	});
68

69
	test('update resource configuration without configuration target defaults to workspace in multi root workspace when no resource is provided', function () {
70
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
71
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
72

73
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.resource', 'value', undefined, undefined);
74

75
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
76
	});
77

78
	test('update resource configuration without configuration target defaults to workspace in folder workspace when resource is provider', function () {
79
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
80
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
81

82
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.resource', 'value', { resource: URI.file('abc') }, undefined);
83

84
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
85
	});
86

87
	test('update resource configuration without configuration target defaults to workspace in folder workspace when no resource is provider', function () {
88
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
89
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
90

91
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.resource', 'value', undefined, undefined);
92

93
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
94
	});
95

96
	test('update window configuration without configuration target defaults to workspace in multi root workspace when no resource is provided', function () {
97
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
98
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
99

100
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.window', 'value', undefined, undefined);
101

102
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
103
	});
104

105
	test('update window configuration without configuration target defaults to workspace in multi root workspace when resource is provided', function () {
106
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
107
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
108

109
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.window', 'value', { resource: URI.file('abc') }, undefined);
110

111
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
112
	});
113

114
	test('update window configuration without configuration target defaults to workspace in folder workspace when resource is provider', function () {
115
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
116
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
117

118
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.window', 'value', { resource: URI.file('abc') }, undefined);
119

120
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
121
	});
122

123
	test('update window configuration without configuration target defaults to workspace in folder workspace when no resource is provider', function () {
124
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
125
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
126

127
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.window', 'value', undefined, undefined);
128

129
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
130
	});
131

132
	test('update resource configuration without configuration target defaults to folder', function () {
133
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
134
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
135

136
		testObject.$updateConfigurationOption(null, 'extHostConfiguration.resource', 'value', { resource: URI.file('abc') }, undefined);
137

138
		assert.strictEqual(ConfigurationTarget.WORKSPACE_FOLDER, target.args[0][3]);
139
	});
140

141
	test('update configuration with user configuration target', function () {
142
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
143
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
144

145
		testObject.$updateConfigurationOption(ConfigurationTarget.USER, 'extHostConfiguration.window', 'value', { resource: URI.file('abc') }, undefined);
146

147
		assert.strictEqual(ConfigurationTarget.USER, target.args[0][3]);
148
	});
149

150
	test('update configuration with workspace configuration target', function () {
151
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
152
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
153

154
		testObject.$updateConfigurationOption(ConfigurationTarget.WORKSPACE, 'extHostConfiguration.window', 'value', { resource: URI.file('abc') }, undefined);
155

156
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
157
	});
158

159
	test('update configuration with folder configuration target', function () {
160
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
161
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
162

163
		testObject.$updateConfigurationOption(ConfigurationTarget.WORKSPACE_FOLDER, 'extHostConfiguration.window', 'value', { resource: URI.file('abc') }, undefined);
164

165
		assert.strictEqual(ConfigurationTarget.WORKSPACE_FOLDER, target.args[0][3]);
166
	});
167

168
	test('remove resource configuration without configuration target defaults to workspace in multi root workspace when no resource is provided', function () {
169
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
170
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
171

172
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.resource', undefined, undefined);
173

174
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
175
	});
176

177
	test('remove resource configuration without configuration target defaults to workspace in folder workspace when resource is provider', function () {
178
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
179
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
180

181
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.resource', { resource: URI.file('abc') }, undefined);
182

183
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
184
	});
185

186
	test('remove resource configuration without configuration target defaults to workspace in folder workspace when no resource is provider', function () {
187
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
188
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
189

190
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.resource', undefined, undefined);
191

192
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
193
	});
194

195
	test('remove window configuration without configuration target defaults to workspace in multi root workspace when no resource is provided', function () {
196
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
197
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
198

199
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.window', undefined, undefined);
200

201
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
202
	});
203

204
	test('remove window configuration without configuration target defaults to workspace in multi root workspace when resource is provided', function () {
205
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
206
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
207

208
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.window', { resource: URI.file('abc') }, undefined);
209

210
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
211
	});
212

213
	test('remove window configuration without configuration target defaults to workspace in folder workspace when resource is provider', function () {
214
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
215
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
216

217
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.window', { resource: URI.file('abc') }, undefined);
218

219
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
220
	});
221

222
	test('remove window configuration without configuration target defaults to workspace in folder workspace when no resource is provider', function () {
223
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.FOLDER });
224
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
225

226
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.window', undefined, undefined);
227

228
		assert.strictEqual(ConfigurationTarget.WORKSPACE, target.args[0][3]);
229
	});
230

231
	test('remove configuration without configuration target defaults to folder', function () {
232
		instantiationService.stub(IWorkspaceContextService, <IWorkspaceContextService>{ getWorkbenchState: () => WorkbenchState.WORKSPACE });
233
		const testObject: MainThreadConfiguration = instantiationService.createInstance(MainThreadConfiguration, SingleProxyRPCProtocol(proxy));
234

235
		testObject.$removeConfigurationOption(null, 'extHostConfiguration.resource', { resource: URI.file('abc') }, undefined);
236

237
		assert.strictEqual(ConfigurationTarget.WORKSPACE_FOLDER, target.args[0][3]);
238
	});
239
});
240

241
Product

Resources

Company
