CoCalc -- extHostConfiguration.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/api/test/browser/extHostConfiguration.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 { URI, UriComponents } from '../../../../base/common/uri.js';
8
import { ExtHostWorkspace } from '../../common/extHostWorkspace.js';
9
import { ConfigurationInspect, ExtHostConfigProvider } from '../../common/extHostConfiguration.js';
10
import { MainThreadConfigurationShape, IConfigurationInitData } from '../../common/extHost.protocol.js';
11
import { ConfigurationModel, ConfigurationModelParser } from '../../../../platform/configuration/common/configurationModels.js';
12
import { TestRPCProtocol } from '../common/testRPCProtocol.js';
13
import { mock } from '../../../../base/test/common/mock.js';
14
import { IWorkspaceFolder, WorkspaceFolder } from '../../../../platform/workspace/common/workspace.js';
15
import { ConfigurationTarget, IConfigurationModel, IConfigurationChange } from '../../../../platform/configuration/common/configuration.js';
16
import { NullLogService } from '../../../../platform/log/common/log.js';
17
import { IExtHostInitDataService } from '../../common/extHostInitDataService.js';
18
import { IExtHostFileSystemInfo } from '../../common/extHostFileSystemInfo.js';
19
import { FileSystemProviderCapabilities } from '../../../../platform/files/common/files.js';
20
import { isLinux } from '../../../../base/common/platform.js';
21
import { IURITransformerService } from '../../common/extHostUriTransformerService.js';
22
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
23

24
suite('ExtHostConfiguration', function () {
25

26
	class RecordingShape extends mock<MainThreadConfigurationShape>() {
27
		lastArgs!: [ConfigurationTarget, string, any];
28
		override $updateConfigurationOption(target: ConfigurationTarget, key: string, value: any): Promise<void> {
29
			this.lastArgs = [target, key, value];
30
			return Promise.resolve(undefined);
31
		}
32
	}
33

34
	function createExtHostWorkspace(): ExtHostWorkspace {
35
		return new ExtHostWorkspace(new TestRPCProtocol(), new class extends mock<IExtHostInitDataService>() { }, new class extends mock<IExtHostFileSystemInfo>() { override getCapabilities() { return isLinux ? FileSystemProviderCapabilities.PathCaseSensitive : undefined; } }, new NullLogService(), new class extends mock<IURITransformerService>() { });
36
	}
37

38
	function createExtHostConfiguration(contents: any = Object.create(null), shape?: MainThreadConfigurationShape) {
39
		if (!shape) {
40
			shape = new class extends mock<MainThreadConfigurationShape>() { };
41
		}
42
		return new ExtHostConfigProvider(shape, createExtHostWorkspace(), createConfigurationData(contents), new NullLogService());
43
	}
44

45
	function createConfigurationData(contents: any): IConfigurationInitData {
46
		return {
47
			defaults: new ConfigurationModel(contents, [], [], undefined, new NullLogService()),
48
			policy: ConfigurationModel.createEmptyModel(new NullLogService()),
49
			application: ConfigurationModel.createEmptyModel(new NullLogService()),
50
			userLocal: new ConfigurationModel(contents, [], [], undefined, new NullLogService()),
51
			userRemote: ConfigurationModel.createEmptyModel(new NullLogService()),
52
			workspace: ConfigurationModel.createEmptyModel(new NullLogService()),
53
			folders: [],
54
			configurationScopes: []
55
		};
56
	}
57

58
	const store = ensureNoDisposablesAreLeakedInTestSuite();
59

60
	test('getConfiguration fails regression test 1.7.1 -> 1.8 #15552', function () {
61
		const extHostConfig = createExtHostConfiguration({
62
			'search': {
63
				'exclude': {
64
					'**/node_modules': true
65
				}
66
			}
67
		});
68

69
		assert.strictEqual(extHostConfig.getConfiguration('search.exclude')['**/node_modules'], true);
70
		assert.strictEqual(extHostConfig.getConfiguration('search.exclude').get('**/node_modules'), true);
71
		assert.strictEqual(extHostConfig.getConfiguration('search').get<any>('exclude')['**/node_modules'], true);
72

73
		assert.strictEqual(extHostConfig.getConfiguration('search.exclude').has('**/node_modules'), true);
74
		assert.strictEqual(extHostConfig.getConfiguration('search').has('exclude.**/node_modules'), true);
75
	});
76

77
	test('has/get', () => {
78

79
		const all = createExtHostConfiguration({
80
			'farboo': {
81
				'config0': true,
82
				'nested': {
83
					'config1': 42,
84
					'config2': 'Das Pferd frisst kein Reis.'
85
				},
86
				'config4': ''
87
			}
88
		});
89

90
		const config = all.getConfiguration('farboo');
91

92
		assert.ok(config.has('config0'));
93
		assert.strictEqual(config.get('config0'), true);
94
		assert.strictEqual(config.get('config4'), '');
95
		assert.strictEqual(config['config0'], true);
96
		assert.strictEqual(config['config4'], '');
97

98
		assert.ok(config.has('nested.config1'));
99
		assert.strictEqual(config.get('nested.config1'), 42);
100
		assert.ok(config.has('nested.config2'));
101
		assert.strictEqual(config.get('nested.config2'), 'Das Pferd frisst kein Reis.');
102

103
		assert.ok(config.has('nested'));
104
		assert.deepStrictEqual(config.get('nested'), { config1: 42, config2: 'Das Pferd frisst kein Reis.' });
105
	});
106

107
	test('get nested config', () => {
108

109
		const all = createExtHostConfiguration({
110
			'farboo': {
111
				'config0': true,
112
				'nested': {
113
					'config1': 42,
114
					'config2': 'Das Pferd frisst kein Reis.'
115
				},
116
				'config4': ''
117
			}
118
		});
119

120
		assert.deepStrictEqual(all.getConfiguration('farboo.nested').get('config1'), 42);
121
		assert.deepStrictEqual(all.getConfiguration('farboo.nested').get('config2'), 'Das Pferd frisst kein Reis.');
122
		assert.deepStrictEqual(all.getConfiguration('farboo.nested')['config1'], 42);
123
		assert.deepStrictEqual(all.getConfiguration('farboo.nested')['config2'], 'Das Pferd frisst kein Reis.');
124
		assert.deepStrictEqual(all.getConfiguration('farboo.nested1').get('config1'), undefined);
125
		assert.deepStrictEqual(all.getConfiguration('farboo.nested1').get('config2'), undefined);
126
		assert.deepStrictEqual(all.getConfiguration('farboo.config0.config1').get('a'), undefined);
127
		assert.deepStrictEqual(all.getConfiguration('farboo.config0.config1')['a'], undefined);
128
	});
129

130
	test('can modify the returned configuration', function () {
131

132
		const all = createExtHostConfiguration({
133
			'farboo': {
134
				'config0': true,
135
				'nested': {
136
					'config1': 42,
137
					'config2': 'Das Pferd frisst kein Reis.'
138
				},
139
				'config4': ''
140
			},
141
			'workbench': {
142
				'colorCustomizations': {
143
					'statusBar.foreground': 'somevalue'
144
				}
145
			}
146
		});
147

148
		let testObject = all.getConfiguration();
149
		let actual = testObject.get<any>('farboo')!;
150
		actual['nested']['config1'] = 41;
151
		assert.strictEqual(41, actual['nested']['config1']);
152
		actual['farboo1'] = 'newValue';
153
		assert.strictEqual('newValue', actual['farboo1']);
154

155
		testObject = all.getConfiguration();
156
		actual = testObject.get('farboo')!;
157
		assert.strictEqual(actual['nested']['config1'], 42);
158
		assert.strictEqual(actual['farboo1'], undefined);
159

160
		testObject = all.getConfiguration();
161
		actual = testObject.get('farboo')!;
162
		assert.strictEqual(actual['config0'], true);
163
		actual['config0'] = false;
164
		assert.strictEqual(actual['config0'], false);
165

166
		testObject = all.getConfiguration();
167
		actual = testObject.get('farboo')!;
168
		assert.strictEqual(actual['config0'], true);
169

170
		testObject = all.getConfiguration();
171
		actual = testObject.inspect('farboo')!;
172
		actual['value'] = 'effectiveValue';
173
		assert.strictEqual('effectiveValue', actual['value']);
174

175
		testObject = all.getConfiguration('workbench');
176
		actual = testObject.get('colorCustomizations')!;
177
		actual['statusBar.foreground'] = undefined;
178
		assert.strictEqual(actual['statusBar.foreground'], undefined);
179
		testObject = all.getConfiguration('workbench');
180
		actual = testObject.get('colorCustomizations')!;
181
		assert.strictEqual(actual['statusBar.foreground'], 'somevalue');
182
	});
183

184
	test('Stringify returned configuration', function () {
185

186
		const all = createExtHostConfiguration({
187
			'farboo': {
188
				'config0': true,
189
				'nested': {
190
					'config1': 42,
191
					'config2': 'Das Pferd frisst kein Reis.'
192
				},
193
				'config4': ''
194
			},
195
			'workbench': {
196
				'colorCustomizations': {
197
					'statusBar.foreground': 'somevalue'
198
				},
199
				'emptyobjectkey': {
200
				}
201
			}
202
		});
203

204
		const testObject = all.getConfiguration();
205
		let actual: any = testObject.get('farboo');
206
		assert.deepStrictEqual(JSON.stringify({
207
			'config0': true,
208
			'nested': {
209
				'config1': 42,
210
				'config2': 'Das Pferd frisst kein Reis.'
211
			},
212
			'config4': ''
213
		}), JSON.stringify(actual));
214

215
		assert.deepStrictEqual(undefined, JSON.stringify(testObject.get('unknownkey')));
216

217
		actual = testObject.get('farboo')!;
218
		actual['config0'] = false;
219
		assert.deepStrictEqual(JSON.stringify({
220
			'config0': false,
221
			'nested': {
222
				'config1': 42,
223
				'config2': 'Das Pferd frisst kein Reis.'
224
			},
225
			'config4': ''
226
		}), JSON.stringify(actual));
227

228
		actual = testObject.get<any>('workbench')!['colorCustomizations']!;
229
		actual['statusBar.background'] = 'anothervalue';
230
		assert.deepStrictEqual(JSON.stringify({
231
			'statusBar.foreground': 'somevalue',
232
			'statusBar.background': 'anothervalue'
233
		}), JSON.stringify(actual));
234

235
		actual = testObject.get('workbench');
236
		actual['unknownkey'] = 'somevalue';
237
		assert.deepStrictEqual(JSON.stringify({
238
			'colorCustomizations': {
239
				'statusBar.foreground': 'somevalue'
240
			},
241
			'emptyobjectkey': {},
242
			'unknownkey': 'somevalue'
243
		}), JSON.stringify(actual));
244

245
		actual = all.getConfiguration('workbench').get('emptyobjectkey');
246
		actual = {
247
			...(actual || {}),
248
			'statusBar.background': `#0ff`,
249
			'statusBar.foreground': `#ff0`,
250
		};
251
		assert.deepStrictEqual(JSON.stringify({
252
			'statusBar.background': `#0ff`,
253
			'statusBar.foreground': `#ff0`,
254
		}), JSON.stringify(actual));
255

256
		actual = all.getConfiguration('workbench').get('unknownkey');
257
		actual = {
258
			...(actual || {}),
259
			'statusBar.background': `#0ff`,
260
			'statusBar.foreground': `#ff0`,
261
		};
262
		assert.deepStrictEqual(JSON.stringify({
263
			'statusBar.background': `#0ff`,
264
			'statusBar.foreground': `#ff0`,
265
		}), JSON.stringify(actual));
266
	});
267

268
	test('cannot modify returned configuration', function () {
269

270
		const all = createExtHostConfiguration({
271
			'farboo': {
272
				'config0': true,
273
				'nested': {
274
					'config1': 42,
275
					'config2': 'Das Pferd frisst kein Reis.'
276
				},
277
				'config4': ''
278
			}
279
		});
280

281
		const testObject: any = all.getConfiguration();
282

283
		try {
284
			testObject['get'] = null;
285
			assert.fail('This should be readonly');
286
		} catch (e) {
287
		}
288

289
		try {
290
			testObject['farboo']['config0'] = false;
291
			assert.fail('This should be readonly');
292
		} catch (e) {
293
		}
294

295
		try {
296
			testObject['farboo']['farboo1'] = 'hello';
297
			assert.fail('This should be readonly');
298
		} catch (e) {
299
		}
300
	});
301

302
	test('inspect in no workspace context', function () {
303
		const testObject = new ExtHostConfigProvider(
304
			new class extends mock<MainThreadConfigurationShape>() { },
305
			createExtHostWorkspace(),
306
			{
307
				defaults: new ConfigurationModel({
308
					'editor': {
309
						'wordWrap': 'off',
310
						'lineNumbers': 'on',
311
						'fontSize': '12px'
312
					}
313
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
314
				policy: ConfigurationModel.createEmptyModel(new NullLogService()),
315
				application: ConfigurationModel.createEmptyModel(new NullLogService()),
316
				userLocal: new ConfigurationModel({
317
					'editor': {
318
						'wordWrap': 'on',
319
						'lineNumbers': 'off'
320
					}
321
				}, ['editor.wordWrap', 'editor.lineNumbers'], [], undefined, new NullLogService()),
322
				userRemote: new ConfigurationModel({
323
					'editor': {
324
						'lineNumbers': 'relative'
325
					}
326
				}, ['editor.lineNumbers'], [], {
327
					'editor': {
328
						'lineNumbers': 'relative',
329
						'fontSize': '14px'
330
					}
331
				}, new NullLogService()),
332
				workspace: new ConfigurationModel({}, [], [], undefined, new NullLogService()),
333
				folders: [],
334
				configurationScopes: []
335
			},
336
			new NullLogService()
337
		);
338

339
		let actual: ConfigurationInspect<string> = testObject.getConfiguration().inspect('editor.wordWrap')!;
340
		assert.strictEqual(actual.defaultValue, 'off');
341
		assert.strictEqual(actual.globalLocalValue, 'on');
342
		assert.strictEqual(actual.globalRemoteValue, undefined);
343
		assert.strictEqual(actual.globalValue, 'on');
344
		assert.strictEqual(actual.workspaceValue, undefined);
345
		assert.strictEqual(actual.workspaceFolderValue, undefined);
346

347
		actual = testObject.getConfiguration('editor').inspect('wordWrap')!;
348
		assert.strictEqual(actual.defaultValue, 'off');
349
		assert.strictEqual(actual.globalLocalValue, 'on');
350
		assert.strictEqual(actual.globalRemoteValue, undefined);
351
		assert.strictEqual(actual.globalValue, 'on');
352
		assert.strictEqual(actual.workspaceValue, undefined);
353
		assert.strictEqual(actual.workspaceFolderValue, undefined);
354

355
		actual = testObject.getConfiguration('editor').inspect('lineNumbers')!;
356
		assert.strictEqual(actual.defaultValue, 'on');
357
		assert.strictEqual(actual.globalLocalValue, 'off');
358
		assert.strictEqual(actual.globalRemoteValue, 'relative');
359
		assert.strictEqual(actual.globalValue, 'relative');
360
		assert.strictEqual(actual.workspaceValue, undefined);
361
		assert.strictEqual(actual.workspaceFolderValue, undefined);
362

363
		assert.strictEqual(testObject.getConfiguration('editor').get('fontSize'), '12px');
364

365
		actual = testObject.getConfiguration('editor').inspect('fontSize')!;
366
		assert.strictEqual(actual.defaultValue, '12px');
367
		assert.strictEqual(actual.globalLocalValue, undefined);
368
		assert.strictEqual(actual.globalRemoteValue, '14px');
369
		assert.strictEqual(actual.globalValue, undefined);
370
		assert.strictEqual(actual.workspaceValue, undefined);
371
		assert.strictEqual(actual.workspaceFolderValue, undefined);
372
	});
373

374
	test('inspect in single root context', function () {
375
		const workspaceUri = URI.file('foo');
376
		const folders: [UriComponents, IConfigurationModel][] = [];
377
		const workspace = new ConfigurationModel({
378
			'editor': {
379
				'wordWrap': 'bounded'
380
			}
381
		}, ['editor.wordWrap'], [], undefined, new NullLogService());
382
		folders.push([workspaceUri, workspace]);
383
		const extHostWorkspace = createExtHostWorkspace();
384
		extHostWorkspace.$initializeWorkspace({
385
			'id': 'foo',
386
			'folders': [aWorkspaceFolder(URI.file('foo'), 0)],
387
			'name': 'foo'
388
		}, true);
389
		const testObject = new ExtHostConfigProvider(
390
			new class extends mock<MainThreadConfigurationShape>() { },
391
			extHostWorkspace,
392
			{
393
				defaults: new ConfigurationModel({
394
					'editor': {
395
						'wordWrap': 'off'
396
					}
397
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
398
				policy: ConfigurationModel.createEmptyModel(new NullLogService()),
399
				application: ConfigurationModel.createEmptyModel(new NullLogService()),
400
				userLocal: new ConfigurationModel({
401
					'editor': {
402
						'wordWrap': 'on'
403
					}
404
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
405
				userRemote: ConfigurationModel.createEmptyModel(new NullLogService()),
406
				workspace,
407
				folders,
408
				configurationScopes: []
409
			},
410
			new NullLogService()
411
		);
412

413
		let actual1: ConfigurationInspect<string> = testObject.getConfiguration().inspect('editor.wordWrap')!;
414
		assert.strictEqual(actual1.defaultValue, 'off');
415
		assert.strictEqual(actual1.globalLocalValue, 'on');
416
		assert.strictEqual(actual1.globalRemoteValue, undefined);
417
		assert.strictEqual(actual1.globalValue, 'on');
418
		assert.strictEqual(actual1.workspaceValue, 'bounded');
419
		assert.strictEqual(actual1.workspaceFolderValue, undefined);
420

421
		actual1 = testObject.getConfiguration('editor').inspect('wordWrap')!;
422
		assert.strictEqual(actual1.defaultValue, 'off');
423
		assert.strictEqual(actual1.globalLocalValue, 'on');
424
		assert.strictEqual(actual1.globalRemoteValue, undefined);
425
		assert.strictEqual(actual1.globalValue, 'on');
426
		assert.strictEqual(actual1.workspaceValue, 'bounded');
427
		assert.strictEqual(actual1.workspaceFolderValue, undefined);
428

429
		let actual2: ConfigurationInspect<string> = testObject.getConfiguration(undefined, workspaceUri).inspect('editor.wordWrap')!;
430
		assert.strictEqual(actual2.defaultValue, 'off');
431
		assert.strictEqual(actual2.globalLocalValue, 'on');
432
		assert.strictEqual(actual2.globalRemoteValue, undefined);
433
		assert.strictEqual(actual2.globalValue, 'on');
434
		assert.strictEqual(actual2.workspaceValue, 'bounded');
435
		assert.strictEqual(actual2.workspaceFolderValue, 'bounded');
436

437
		actual2 = testObject.getConfiguration('editor', workspaceUri).inspect('wordWrap')!;
438
		assert.strictEqual(actual2.defaultValue, 'off');
439
		assert.strictEqual(actual2.globalLocalValue, 'on');
440
		assert.strictEqual(actual2.globalRemoteValue, undefined);
441
		assert.strictEqual(actual2.globalValue, 'on');
442
		assert.strictEqual(actual2.workspaceValue, 'bounded');
443
		assert.strictEqual(actual2.workspaceFolderValue, 'bounded');
444
	});
445

446
	test('inspect in multi root context', function () {
447
		const workspace = new ConfigurationModel({
448
			'editor': {
449
				'wordWrap': 'bounded'
450
			}
451
		}, ['editor.wordWrap'], [], undefined, new NullLogService());
452

453
		const firstRoot = URI.file('foo1');
454
		const secondRoot = URI.file('foo2');
455
		const thirdRoot = URI.file('foo3');
456
		const folders: [UriComponents, IConfigurationModel][] = [];
457
		folders.push([firstRoot, new ConfigurationModel({
458
			'editor': {
459
				'wordWrap': 'off',
460
				'lineNumbers': 'relative'
461
			}
462
		}, ['editor.wordWrap'], [], undefined, new NullLogService())]);
463
		folders.push([secondRoot, new ConfigurationModel({
464
			'editor': {
465
				'wordWrap': 'on'
466
			}
467
		}, ['editor.wordWrap'], [], undefined, new NullLogService())]);
468
		folders.push([thirdRoot, new ConfigurationModel({}, [], [], undefined, new NullLogService())]);
469

470
		const extHostWorkspace = createExtHostWorkspace();
471
		extHostWorkspace.$initializeWorkspace({
472
			'id': 'foo',
473
			'folders': [aWorkspaceFolder(firstRoot, 0), aWorkspaceFolder(secondRoot, 1)],
474
			'name': 'foo'
475
		}, true);
476
		const testObject = new ExtHostConfigProvider(
477
			new class extends mock<MainThreadConfigurationShape>() { },
478
			extHostWorkspace,
479
			{
480
				defaults: new ConfigurationModel({
481
					'editor': {
482
						'wordWrap': 'off',
483
						'lineNumbers': 'on'
484
					}
485
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
486
				policy: ConfigurationModel.createEmptyModel(new NullLogService()),
487
				application: ConfigurationModel.createEmptyModel(new NullLogService()),
488
				userLocal: new ConfigurationModel({
489
					'editor': {
490
						'wordWrap': 'on'
491
					}
492
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
493
				userRemote: ConfigurationModel.createEmptyModel(new NullLogService()),
494
				workspace,
495
				folders,
496
				configurationScopes: []
497
			},
498
			new NullLogService()
499
		);
500

501
		let actual1: ConfigurationInspect<string> = testObject.getConfiguration().inspect('editor.wordWrap')!;
502
		assert.strictEqual(actual1.defaultValue, 'off');
503
		assert.strictEqual(actual1.globalValue, 'on');
504
		assert.strictEqual(actual1.globalLocalValue, 'on');
505
		assert.strictEqual(actual1.globalRemoteValue, undefined);
506
		assert.strictEqual(actual1.workspaceValue, 'bounded');
507
		assert.strictEqual(actual1.workspaceFolderValue, undefined);
508

509
		actual1 = testObject.getConfiguration('editor').inspect('wordWrap')!;
510
		assert.strictEqual(actual1.defaultValue, 'off');
511
		assert.strictEqual(actual1.globalValue, 'on');
512
		assert.strictEqual(actual1.globalLocalValue, 'on');
513
		assert.strictEqual(actual1.globalRemoteValue, undefined);
514
		assert.strictEqual(actual1.workspaceValue, 'bounded');
515
		assert.strictEqual(actual1.workspaceFolderValue, undefined);
516

517
		actual1 = testObject.getConfiguration('editor').inspect('lineNumbers')!;
518
		assert.strictEqual(actual1.defaultValue, 'on');
519
		assert.strictEqual(actual1.globalValue, undefined);
520
		assert.strictEqual(actual1.globalLocalValue, undefined);
521
		assert.strictEqual(actual1.globalRemoteValue, undefined);
522
		assert.strictEqual(actual1.workspaceValue, undefined);
523
		assert.strictEqual(actual1.workspaceFolderValue, undefined);
524

525
		let actual2: ConfigurationInspect<string> = testObject.getConfiguration(undefined, firstRoot).inspect('editor.wordWrap')!;
526
		assert.strictEqual(actual2.defaultValue, 'off');
527
		assert.strictEqual(actual2.globalValue, 'on');
528
		assert.strictEqual(actual2.globalLocalValue, 'on');
529
		assert.strictEqual(actual2.globalRemoteValue, undefined);
530
		assert.strictEqual(actual2.workspaceValue, 'bounded');
531
		assert.strictEqual(actual2.workspaceFolderValue, 'off');
532

533
		actual2 = testObject.getConfiguration('editor', firstRoot).inspect('wordWrap')!;
534
		assert.strictEqual(actual2.defaultValue, 'off');
535
		assert.strictEqual(actual2.globalValue, 'on');
536
		assert.strictEqual(actual2.globalLocalValue, 'on');
537
		assert.strictEqual(actual2.globalRemoteValue, undefined);
538
		assert.strictEqual(actual2.workspaceValue, 'bounded');
539
		assert.strictEqual(actual2.workspaceFolderValue, 'off');
540

541
		actual2 = testObject.getConfiguration('editor', firstRoot).inspect('lineNumbers')!;
542
		assert.strictEqual(actual2.defaultValue, 'on');
543
		assert.strictEqual(actual2.globalValue, undefined);
544
		assert.strictEqual(actual2.globalLocalValue, undefined);
545
		assert.strictEqual(actual2.globalRemoteValue, undefined);
546
		assert.strictEqual(actual2.workspaceValue, undefined);
547
		assert.strictEqual(actual2.workspaceFolderValue, 'relative');
548

549
		actual2 = testObject.getConfiguration(undefined, secondRoot).inspect('editor.wordWrap')!;
550
		assert.strictEqual(actual2.defaultValue, 'off');
551
		assert.strictEqual(actual2.globalValue, 'on');
552
		assert.strictEqual(actual2.globalLocalValue, 'on');
553
		assert.strictEqual(actual2.globalRemoteValue, undefined);
554
		assert.strictEqual(actual2.workspaceValue, 'bounded');
555
		assert.strictEqual(actual2.workspaceFolderValue, 'on');
556

557
		actual2 = testObject.getConfiguration('editor', secondRoot).inspect('wordWrap')!;
558
		assert.strictEqual(actual2.defaultValue, 'off');
559
		assert.strictEqual(actual2.globalValue, 'on');
560
		assert.strictEqual(actual2.globalLocalValue, 'on');
561
		assert.strictEqual(actual2.globalRemoteValue, undefined);
562
		assert.strictEqual(actual2.workspaceValue, 'bounded');
563
		assert.strictEqual(actual2.workspaceFolderValue, 'on');
564

565
		actual2 = testObject.getConfiguration(undefined, thirdRoot).inspect('editor.wordWrap')!;
566
		assert.strictEqual(actual2.defaultValue, 'off');
567
		assert.strictEqual(actual2.globalValue, 'on');
568
		assert.strictEqual(actual2.globalLocalValue, 'on');
569
		assert.strictEqual(actual2.globalRemoteValue, undefined);
570
		assert.strictEqual(actual2.workspaceValue, 'bounded');
571
		assert.ok(Object.keys(actual2).indexOf('workspaceFolderValue') !== -1);
572
		assert.strictEqual(actual2.workspaceFolderValue, undefined);
573

574
		actual2 = testObject.getConfiguration('editor', thirdRoot).inspect('wordWrap')!;
575
		assert.strictEqual(actual2.defaultValue, 'off');
576
		assert.strictEqual(actual2.globalValue, 'on');
577
		assert.strictEqual(actual2.globalLocalValue, 'on');
578
		assert.strictEqual(actual2.globalRemoteValue, undefined);
579
		assert.strictEqual(actual2.workspaceValue, 'bounded');
580
		assert.ok(Object.keys(actual2).indexOf('workspaceFolderValue') !== -1);
581
		assert.strictEqual(actual2.workspaceFolderValue, undefined);
582
	});
583

584
	test('inspect with language overrides', function () {
585
		const firstRoot = URI.file('foo1');
586
		const secondRoot = URI.file('foo2');
587
		const folders: [UriComponents, IConfigurationModel][] = [];
588
		folders.push([firstRoot, toConfigurationModel({
589
			'editor.wordWrap': 'bounded',
590
			'[typescript]': {
591
				'editor.wordWrap': 'unbounded',
592
			}
593
		})]);
594
		folders.push([secondRoot, toConfigurationModel({})]);
595

596
		const extHostWorkspace = createExtHostWorkspace();
597
		extHostWorkspace.$initializeWorkspace({
598
			'id': 'foo',
599
			'folders': [aWorkspaceFolder(firstRoot, 0), aWorkspaceFolder(secondRoot, 1)],
600
			'name': 'foo'
601
		}, true);
602
		const testObject = new ExtHostConfigProvider(
603
			new class extends mock<MainThreadConfigurationShape>() { },
604
			extHostWorkspace,
605
			{
606
				defaults: toConfigurationModel({
607
					'editor.wordWrap': 'off',
608
					'[markdown]': {
609
						'editor.wordWrap': 'bounded',
610
					}
611
				}),
612
				policy: ConfigurationModel.createEmptyModel(new NullLogService()),
613
				application: ConfigurationModel.createEmptyModel(new NullLogService()),
614
				userLocal: toConfigurationModel({
615
					'editor.wordWrap': 'bounded',
616
					'[typescript]': {
617
						'editor.lineNumbers': 'off',
618
					}
619
				}),
620
				userRemote: ConfigurationModel.createEmptyModel(new NullLogService()),
621
				workspace: toConfigurationModel({
622
					'[typescript]': {
623
						'editor.wordWrap': 'unbounded',
624
						'editor.lineNumbers': 'off',
625
					}
626
				}),
627
				folders,
628
				configurationScopes: []
629
			},
630
			new NullLogService()
631
		);
632

633
		let actual: ConfigurationInspect<string> = testObject.getConfiguration(undefined, { uri: firstRoot, languageId: 'typescript' }).inspect('editor.wordWrap')!;
634
		assert.strictEqual(actual.defaultValue, 'off');
635
		assert.strictEqual(actual.globalValue, 'bounded');
636
		assert.strictEqual(actual.globalLocalValue, 'bounded');
637
		assert.strictEqual(actual.globalRemoteValue, undefined);
638
		assert.strictEqual(actual.workspaceValue, undefined);
639
		assert.strictEqual(actual.workspaceFolderValue, 'bounded');
640
		assert.strictEqual(actual.defaultLanguageValue, undefined);
641
		assert.strictEqual(actual.globalLanguageValue, undefined);
642
		assert.strictEqual(actual.workspaceLanguageValue, 'unbounded');
643
		assert.strictEqual(actual.workspaceFolderLanguageValue, 'unbounded');
644
		assert.deepStrictEqual(actual.languageIds, ['markdown', 'typescript']);
645

646
		actual = testObject.getConfiguration(undefined, { uri: secondRoot, languageId: 'typescript' }).inspect('editor.wordWrap')!;
647
		assert.strictEqual(actual.defaultValue, 'off');
648
		assert.strictEqual(actual.globalValue, 'bounded');
649
		assert.strictEqual(actual.globalLocalValue, 'bounded');
650
		assert.strictEqual(actual.globalRemoteValue, undefined);
651
		assert.strictEqual(actual.workspaceValue, undefined);
652
		assert.strictEqual(actual.workspaceFolderValue, undefined);
653
		assert.strictEqual(actual.defaultLanguageValue, undefined);
654
		assert.strictEqual(actual.globalLanguageValue, undefined);
655
		assert.strictEqual(actual.workspaceLanguageValue, 'unbounded');
656
		assert.strictEqual(actual.workspaceFolderLanguageValue, undefined);
657
		assert.deepStrictEqual(actual.languageIds, ['markdown', 'typescript']);
658
	});
659

660
	test('application is not set in inspect', () => {
661

662
		const testObject = new ExtHostConfigProvider(
663
			new class extends mock<MainThreadConfigurationShape>() { },
664
			createExtHostWorkspace(),
665
			{
666
				defaults: new ConfigurationModel({
667
					'editor': {
668
						'wordWrap': 'off',
669
						'lineNumbers': 'on',
670
						'fontSize': '12px'
671
					}
672
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
673
				policy: ConfigurationModel.createEmptyModel(new NullLogService()),
674
				application: new ConfigurationModel({
675
					'editor': {
676
						'wordWrap': 'on'
677
					}
678
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
679
				userLocal: new ConfigurationModel({
680
					'editor': {
681
						'wordWrap': 'auto',
682
						'lineNumbers': 'off'
683
					}
684
				}, ['editor.wordWrap'], [], undefined, new NullLogService()),
685
				userRemote: ConfigurationModel.createEmptyModel(new NullLogService()),
686
				workspace: new ConfigurationModel({}, [], [], undefined, new NullLogService()),
687
				folders: [],
688
				configurationScopes: []
689
			},
690
			new NullLogService()
691
		);
692

693
		let actual: ConfigurationInspect<string> = testObject.getConfiguration().inspect('editor.wordWrap')!;
694
		assert.strictEqual(actual.defaultValue, 'off');
695
		assert.strictEqual(actual.globalValue, 'auto');
696
		assert.strictEqual(actual.globalLocalValue, 'auto');
697
		assert.strictEqual(actual.globalRemoteValue, undefined);
698
		assert.strictEqual(actual.workspaceValue, undefined);
699
		assert.strictEqual(actual.workspaceFolderValue, undefined);
700
		assert.strictEqual(testObject.getConfiguration().get('editor.wordWrap'), 'auto');
701

702
		actual = testObject.getConfiguration().inspect('editor.lineNumbers')!;
703
		assert.strictEqual(actual.defaultValue, 'on');
704
		assert.strictEqual(actual.globalValue, 'off');
705
		assert.strictEqual(actual.globalLocalValue, 'off');
706
		assert.strictEqual(actual.globalRemoteValue, undefined);
707
		assert.strictEqual(actual.workspaceValue, undefined);
708
		assert.strictEqual(actual.workspaceFolderValue, undefined);
709
		assert.strictEqual(testObject.getConfiguration().get('editor.lineNumbers'), 'off');
710

711
		actual = testObject.getConfiguration().inspect('editor.fontSize')!;
712
		assert.strictEqual(actual.defaultValue, '12px');
713
		assert.strictEqual(actual.globalLocalValue, undefined);
714
		assert.strictEqual(actual.globalRemoteValue, undefined);
715
		assert.strictEqual(actual.globalValue, undefined);
716
		assert.strictEqual(actual.workspaceValue, undefined);
717
		assert.strictEqual(actual.workspaceFolderValue, undefined);
718
		assert.strictEqual(testObject.getConfiguration().get('editor.fontSize'), '12px');
719
	});
720

721
	test('getConfiguration vs get', function () {
722

723
		const all = createExtHostConfiguration({
724
			'farboo': {
725
				'config0': true,
726
				'config4': 38
727
			}
728
		});
729

730
		let config = all.getConfiguration('farboo.config0');
731
		assert.strictEqual(config.get(''), undefined);
732
		assert.strictEqual(config.has(''), false);
733

734
		config = all.getConfiguration('farboo');
735
		assert.strictEqual(config.get('config0'), true);
736
		assert.strictEqual(config.has('config0'), true);
737
	});
738

739
	test('name vs property', function () {
740
		const all = createExtHostConfiguration({
741
			'farboo': {
742
				'get': 'get-prop'
743
			}
744
		});
745
		const config = all.getConfiguration('farboo');
746

747
		assert.ok(config.has('get'));
748
		assert.strictEqual(config.get('get'), 'get-prop');
749
		assert.deepStrictEqual(config['get'], config.get);
750
		assert.throws(() => config['get'] = <any>'get-prop');
751
	});
752

753
	test('update: no target passes null', function () {
754
		const shape = new RecordingShape();
755
		const allConfig = createExtHostConfiguration({
756
			'foo': {
757
				'bar': 1,
758
				'far': 1
759
			}
760
		}, shape);
761

762
		const config = allConfig.getConfiguration('foo');
763
		config.update('bar', 42);
764

765
		assert.strictEqual(shape.lastArgs[0], null);
766
	});
767

768
	test('update/section to key', function () {
769

770
		const shape = new RecordingShape();
771
		const allConfig = createExtHostConfiguration({
772
			'foo': {
773
				'bar': 1,
774
				'far': 1
775
			}
776
		}, shape);
777

778
		let config = allConfig.getConfiguration('foo');
779
		config.update('bar', 42, true);
780

781
		assert.strictEqual(shape.lastArgs[0], ConfigurationTarget.USER);
782
		assert.strictEqual(shape.lastArgs[1], 'foo.bar');
783
		assert.strictEqual(shape.lastArgs[2], 42);
784

785
		config = allConfig.getConfiguration('');
786
		config.update('bar', 42, true);
787
		assert.strictEqual(shape.lastArgs[1], 'bar');
788

789
		config.update('foo.bar', 42, true);
790
		assert.strictEqual(shape.lastArgs[1], 'foo.bar');
791
	});
792

793
	test('update, what is #15834', function () {
794
		const shape = new RecordingShape();
795
		const allConfig = createExtHostConfiguration({
796
			'editor': {
797
				'formatOnSave': true
798
			}
799
		}, shape);
800

801
		allConfig.getConfiguration('editor').update('formatOnSave', { extensions: ['ts'] });
802
		assert.strictEqual(shape.lastArgs[1], 'editor.formatOnSave');
803
		assert.deepStrictEqual(shape.lastArgs[2], { extensions: ['ts'] });
804
	});
805

806
	test('update/error-state not OK', function () {
807

808
		const shape = new class extends mock<MainThreadConfigurationShape>() {
809
			override $updateConfigurationOption(target: ConfigurationTarget, key: string, value: any): Promise<any> {
810
				return Promise.reject(new Error('Unknown Key')); // something !== OK
811
			}
812
		};
813

814
		return createExtHostConfiguration({}, shape)
815
			.getConfiguration('')
816
			.update('', true, false)
817
			.then(() => assert.ok(false), err => { /* expecting rejection */ });
818
	});
819

820
	test('configuration change event', (done) => {
821

822
		const workspaceFolder = aWorkspaceFolder(URI.file('folder1'), 0);
823
		const extHostWorkspace = createExtHostWorkspace();
824
		extHostWorkspace.$initializeWorkspace({
825
			'id': 'foo',
826
			'folders': [workspaceFolder],
827
			'name': 'foo'
828
		}, true);
829
		const testObject = new ExtHostConfigProvider(
830
			new class extends mock<MainThreadConfigurationShape>() { },
831
			extHostWorkspace,
832
			createConfigurationData({
833
				'farboo': {
834
					'config': false,
835
					'updatedConfig': false
836
				}
837
			}),
838
			new NullLogService()
839
		);
840

841
		const newConfigData = createConfigurationData({
842
			'farboo': {
843
				'config': false,
844
				'updatedConfig': true,
845
				'newConfig': true,
846
			}
847
		});
848
		const configEventData: IConfigurationChange = { keys: ['farboo.updatedConfig', 'farboo.newConfig'], overrides: [] };
849
		store.add(testObject.onDidChangeConfiguration(e => {
850

851
			assert.deepStrictEqual(testObject.getConfiguration().get('farboo'), {
852
				'config': false,
853
				'updatedConfig': true,
854
				'newConfig': true,
855
			});
856

857
			assert.ok(e.affectsConfiguration('farboo'));
858
			assert.ok(e.affectsConfiguration('farboo', workspaceFolder.uri));
859
			assert.ok(e.affectsConfiguration('farboo', URI.file('any')));
860

861
			assert.ok(e.affectsConfiguration('farboo.updatedConfig'));
862
			assert.ok(e.affectsConfiguration('farboo.updatedConfig', workspaceFolder.uri));
863
			assert.ok(e.affectsConfiguration('farboo.updatedConfig', URI.file('any')));
864

865
			assert.ok(e.affectsConfiguration('farboo.newConfig'));
866
			assert.ok(e.affectsConfiguration('farboo.newConfig', workspaceFolder.uri));
867
			assert.ok(e.affectsConfiguration('farboo.newConfig', URI.file('any')));
868

869
			assert.ok(!e.affectsConfiguration('farboo.config'));
870
			assert.ok(!e.affectsConfiguration('farboo.config', workspaceFolder.uri));
871
			assert.ok(!e.affectsConfiguration('farboo.config', URI.file('any')));
872
			done();
873
		}));
874

875
		testObject.$acceptConfigurationChanged(newConfigData, configEventData);
876
	});
877

878
	test('get return instance of array value', function () {
879
		const testObject = createExtHostConfiguration({ 'far': { 'boo': [] } });
880

881
		const value: string[] = testObject.getConfiguration().get('far.boo', []);
882
		value.push('a');
883

884
		const actual = testObject.getConfiguration().get('far.boo', []);
885
		assert.deepStrictEqual(actual, []);
886
	});
887

888
	function aWorkspaceFolder(uri: URI, index: number, name: string = ''): IWorkspaceFolder {
889
		return new WorkspaceFolder({ uri, name, index });
890
	}
891

892
	function toConfigurationModel(obj: any): ConfigurationModel {
893
		const parser = new ConfigurationModelParser('test', new NullLogService());
894
		parser.parse(JSON.stringify(obj));
895
		return parser.configurationModel;
896
	}
897

898
});
899

900
Product

Resources

Company
