CoCalc -- configurationService.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/services/configuration/test/browser/configurationService.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 { IEnvironmentService } from '../../../../../platform/environment/common/environment.js';
11
import { IConfigurationRegistry, Extensions as ConfigurationExtensions, ConfigurationScope, keyFromOverrideIdentifiers } from '../../../../../platform/configuration/common/configurationRegistry.js';
12
import { WorkspaceService } from '../../browser/configurationService.js';
13
import { ConfigurationEditingErrorCode } from '../../common/configurationEditing.js';
14
import { IFileService } from '../../../../../platform/files/common/files.js';
15
import { IWorkspaceContextService, WorkbenchState, IWorkspaceFoldersChangeEvent, ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from '../../../../../platform/workspace/common/workspace.js';
16
import { ConfigurationTarget, IConfigurationService, IConfigurationChangeEvent } from '../../../../../platform/configuration/common/configuration.js';
17
import { workbenchInstantiationService, RemoteFileSystemProvider, TestEnvironmentService, TestTextFileService } from '../../../../test/browser/workbenchTestServices.js';
18
import { TestInstantiationService } from '../../../../../platform/instantiation/test/common/instantiationServiceMock.js';
19
import { ITextFileService } from '../../../textfile/common/textfiles.js';
20
import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
21
import { TextModelResolverService } from '../../../textmodelResolver/common/textModelResolverService.js';
22
import { IJSONEditingService } from '../../common/jsonEditing.js';
23
import { JSONEditingService } from '../../common/jsonEditingService.js';
24
import { Schemas } from '../../../../../base/common/network.js';
25
import { joinPath, dirname, basename } from '../../../../../base/common/resources.js';
26
import { isLinux, isMacintosh } from '../../../../../base/common/platform.js';
27
import { IRemoteAgentService } from '../../../remote/common/remoteAgentService.js';
28
import { FileService } from '../../../../../platform/files/common/fileService.js';
29
import { NullLogService } from '../../../../../platform/log/common/log.js';
30
import { IRemoteAgentEnvironment } from '../../../../../platform/remote/common/remoteAgentEnvironment.js';
31
import { APPLY_ALL_PROFILES_SETTING, IConfigurationCache } from '../../common/configuration.js';
32
import { SignService } from '../../../../../platform/sign/browser/signService.js';
33
import { FileUserDataProvider } from '../../../../../platform/userData/common/fileUserDataProvider.js';
34
import { IKeybindingEditingService, KeybindingsEditingService } from '../../../keybinding/common/keybindingEditing.js';
35
import { IWorkbenchEnvironmentService } from '../../../environment/common/environmentService.js';
36
import { timeout } from '../../../../../base/common/async.js';
37
import { VSBuffer } from '../../../../../base/common/buffer.js';
38
import { Event } from '../../../../../base/common/event.js';
39
import { UriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentityService.js';
40
import { InMemoryFileSystemProvider } from '../../../../../platform/files/common/inMemoryFilesystemProvider.js';
41
import { BrowserWorkbenchEnvironmentService, IBrowserWorkbenchEnvironmentService } from '../../../environment/browser/environmentService.js';
42
import { RemoteAgentService } from '../../../remote/browser/remoteAgentService.js';
43
import { RemoteAuthorityResolverService } from '../../../../../platform/remote/browser/remoteAuthorityResolverService.js';
44
import { hash } from '../../../../../base/common/hash.js';
45
import { TestProductService } from '../../../../test/common/workbenchTestServices.js';
46
import { IUserDataProfilesService, toUserDataProfile, UserDataProfilesService } from '../../../../../platform/userDataProfile/common/userDataProfile.js';
47
import { NullPolicyService } from '../../../../../platform/policy/common/policy.js';
48
import { FilePolicyService } from '../../../../../platform/policy/common/filePolicyService.js';
49
import { runWithFakedTimers } from '../../../../../base/test/common/timeTravelScheduler.js';
50
import { UserDataProfileService } from '../../../userDataProfile/common/userDataProfileService.js';
51
import { IUserDataProfileService } from '../../../userDataProfile/common/userDataProfile.js';
52
import { TasksSchemaProperties } from '../../../../contrib/tasks/common/tasks.js';
53
import { RemoteSocketFactoryService } from '../../../../../platform/remote/common/remoteSocketFactoryService.js';
54
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
55
import { PolicyCategory } from '../../../../../base/common/policy.js';
56

57
function convertToWorkspacePayload(folder: URI): ISingleFolderWorkspaceIdentifier {
58
	return {
59
		id: hash(folder.toString()).toString(16),
60
		uri: folder
61
	};
62
}
63

64
class ConfigurationCache implements IConfigurationCache {
65
	needsCaching(resource: URI): boolean { return false; }
66
	async read(): Promise<string> { return ''; }
67
	async write(): Promise<void> { }
68
	async remove(): Promise<void> { }
69
}
70

71
const ROOT = URI.file('tests').with({ scheme: 'vscode-tests' });
72

73
suite('WorkspaceContextService - Folder', () => {
74

75
	const folderName = 'Folder A';
76
	let folder: URI;
77
	let testObject: WorkspaceService;
78
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
79

80
	setup(async () => {
81
		const logService = new NullLogService();
82
		const fileService = disposables.add(new FileService(logService));
83
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
84
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
85

86
		folder = joinPath(ROOT, folderName);
87
		await fileService.createFolder(folder);
88

89
		const environmentService = TestEnvironmentService;
90
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
91
		const userDataProfilesService = disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService));
92
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
93
		const userDataProfileService = disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile));
94
		testObject = disposables.add(new WorkspaceService(
95
			{ configurationCache: new ConfigurationCache() },
96
			environmentService,
97
			userDataProfileService,
98
			userDataProfilesService,
99
			fileService,
100
			disposables.add(new RemoteAgentService(
101
				new RemoteSocketFactoryService(),
102
				userDataProfileService,
103
				environmentService,
104
				TestProductService,
105
				disposables.add(new RemoteAuthorityResolverService(false, undefined, undefined, undefined, TestProductService, logService)),
106
				new SignService(TestProductService), new NullLogService())),
107
			uriIdentityService,
108
			new NullLogService(),
109
			new NullPolicyService()));
110
		await (<WorkspaceService>testObject).initialize(convertToWorkspacePayload(folder));
111
	});
112

113
	test('getWorkspace()', () => {
114
		const actual = testObject.getWorkspace();
115

116
		assert.strictEqual(actual.folders.length, 1);
117
		assert.strictEqual(actual.folders[0].uri.path, folder.path);
118
		assert.strictEqual(actual.folders[0].name, folderName);
119
		assert.strictEqual(actual.folders[0].index, 0);
120
		assert.ok(!actual.configuration);
121
	});
122

123
	test('getWorkbenchState()', () => {
124
		const actual = testObject.getWorkbenchState();
125

126
		assert.strictEqual(actual, WorkbenchState.FOLDER);
127
	});
128

129
	test('getWorkspaceFolder()', () => {
130
		const actual = testObject.getWorkspaceFolder(joinPath(folder, 'a'));
131

132
		assert.strictEqual(actual, testObject.getWorkspace().folders[0]);
133
	});
134

135
	test('getWorkspaceFolder() - queries in workspace folder', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
136

137
		const logService = new NullLogService();
138
		const fileService = disposables.add(new FileService(logService));
139
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
140
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
141

142
		const folder = joinPath(ROOT, folderName).with({ query: 'myquery=1' });
143
		await fileService.createFolder(folder);
144

145
		const environmentService = TestEnvironmentService;
146
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
147
		const userDataProfilesService = disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService));
148
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
149
		const userDataProfileService = disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile));
150
		const testObject = disposables.add(new WorkspaceService(
151
			{ configurationCache: new ConfigurationCache() },
152
			environmentService,
153
			userDataProfileService,
154
			userDataProfilesService,
155
			fileService,
156
			disposables.add(new RemoteAgentService(new RemoteSocketFactoryService(), userDataProfileService, environmentService, TestProductService, disposables.add(new RemoteAuthorityResolverService(false, undefined, undefined, undefined, TestProductService, logService)), new SignService(TestProductService), new NullLogService())),
157
			uriIdentityService,
158
			new NullLogService(),
159
			new NullPolicyService()));
160
		await (<WorkspaceService>testObject).initialize(convertToWorkspacePayload(folder));
161

162
		const actual = testObject.getWorkspaceFolder(joinPath(folder, 'a'));
163

164
		assert.strictEqual(actual, testObject.getWorkspace().folders[0]);
165
	}));
166

167
	test('getWorkspaceFolder() - queries in resource', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
168

169
		const logService = new NullLogService();
170
		const fileService = disposables.add(new FileService(logService));
171
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
172
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
173

174
		const folder = joinPath(ROOT, folderName);
175
		await fileService.createFolder(folder);
176

177
		const environmentService = TestEnvironmentService;
178
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
179
		const userDataProfilesService = disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService));
180
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
181
		const userDataProfileService = disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile));
182
		const testObject = disposables.add(new WorkspaceService(
183
			{ configurationCache: new ConfigurationCache() },
184
			environmentService,
185
			userDataProfileService,
186
			userDataProfilesService,
187
			fileService,
188
			disposables.add(new RemoteAgentService(new RemoteSocketFactoryService(), userDataProfileService, environmentService, TestProductService, disposables.add(new RemoteAuthorityResolverService(false, undefined, undefined, undefined, TestProductService, logService)), new SignService(TestProductService), new NullLogService())),
189
			uriIdentityService,
190
			new NullLogService(),
191
			new NullPolicyService()));
192
		await testObject.initialize(convertToWorkspacePayload(folder));
193

194
		const actual = testObject.getWorkspaceFolder(joinPath(folder, 'a').with({ query: 'myquery=1' }));
195

196
		assert.strictEqual(actual, testObject.getWorkspace().folders[0]);
197
	}));
198

199
	test('isCurrentWorkspace() => true', () => {
200
		assert.ok(testObject.isCurrentWorkspace(folder));
201
	});
202

203
	test('isCurrentWorkspace() => false', () => {
204
		assert.ok(!testObject.isCurrentWorkspace(joinPath(dirname(folder), 'abc')));
205
	});
206

207
	test('workspace is complete', () => testObject.getCompleteWorkspace());
208
});
209

210
suite('WorkspaceContextService - Workspace', () => {
211

212
	let testObject: WorkspaceService;
213
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
214

215
	setup(async () => {
216
		const logService = new NullLogService();
217
		const fileService = disposables.add(new FileService(logService));
218
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
219
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
220

221
		const appSettingsHome = joinPath(ROOT, 'user');
222
		const folderA = joinPath(ROOT, 'a');
223
		const folderB = joinPath(ROOT, 'b');
224
		const configResource = joinPath(ROOT, 'vsctests.code-workspace');
225
		const workspace = { folders: [{ path: folderA.path }, { path: folderB.path }] };
226

227
		await fileService.createFolder(appSettingsHome);
228
		await fileService.createFolder(folderA);
229
		await fileService.createFolder(folderB);
230
		await fileService.writeFile(configResource, VSBuffer.fromString(JSON.stringify(workspace, null, '\t')));
231

232
		const instantiationService = workbenchInstantiationService(undefined, disposables);
233
		const environmentService = TestEnvironmentService;
234
		const remoteAgentService = disposables.add(disposables.add(instantiationService.createInstance(RemoteAgentService)));
235
		instantiationService.stub(IRemoteAgentService, remoteAgentService);
236
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
237
		const userDataProfilesService = instantiationService.stub(IUserDataProfilesService, disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService)));
238
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
239
		testObject = disposables.add(new WorkspaceService(
240
			{ configurationCache: new ConfigurationCache() },
241
			environmentService,
242
			disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile)),
243
			userDataProfilesService, fileService, remoteAgentService, uriIdentityService, new NullLogService(), new NullPolicyService()));
244

245
		instantiationService.stub(IWorkspaceContextService, testObject);
246
		instantiationService.stub(IConfigurationService, testObject);
247
		instantiationService.stub(IEnvironmentService, environmentService);
248

249
		await testObject.initialize(getWorkspaceIdentifier(configResource));
250
		testObject.acquireInstantiationService(instantiationService);
251
	});
252

253
	test('workspace folders', () => {
254
		const actual = testObject.getWorkspace().folders;
255

256
		assert.strictEqual(actual.length, 2);
257
		assert.strictEqual(basename(actual[0].uri), 'a');
258
		assert.strictEqual(basename(actual[1].uri), 'b');
259
	});
260

261
	test('getWorkbenchState()', () => {
262
		const actual = testObject.getWorkbenchState();
263

264
		assert.strictEqual(actual, WorkbenchState.WORKSPACE);
265
	});
266

267

268
	test('workspace is complete', () => testObject.getCompleteWorkspace());
269

270
});
271

272
suite('WorkspaceContextService - Workspace Editing', () => {
273

274
	let testObject: WorkspaceService, fileService: IFileService;
275
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
276

277
	setup(async () => {
278
		const logService = new NullLogService();
279
		fileService = disposables.add(new FileService(logService));
280
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
281
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
282

283
		const appSettingsHome = joinPath(ROOT, 'user');
284
		const folderA = joinPath(ROOT, 'a');
285
		const folderB = joinPath(ROOT, 'b');
286
		const configResource = joinPath(ROOT, 'vsctests.code-workspace');
287
		const workspace = { folders: [{ path: folderA.path }, { path: folderB.path }] };
288

289
		await fileService.createFolder(appSettingsHome);
290
		await fileService.createFolder(folderA);
291
		await fileService.createFolder(folderB);
292
		await fileService.writeFile(configResource, VSBuffer.fromString(JSON.stringify(workspace, null, '\t')));
293

294
		const instantiationService = workbenchInstantiationService(undefined, disposables);
295
		const environmentService = TestEnvironmentService;
296
		const remoteAgentService = disposables.add(instantiationService.createInstance(RemoteAgentService));
297
		instantiationService.stub(IRemoteAgentService, remoteAgentService);
298
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
299
		const userDataProfilesService = instantiationService.stub(IUserDataProfilesService, disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService)));
300
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
301
		testObject = disposables.add(new WorkspaceService(
302
			{ configurationCache: new ConfigurationCache() },
303
			environmentService,
304
			disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile)),
305
			userDataProfilesService, fileService, remoteAgentService, uriIdentityService, new NullLogService(), new NullPolicyService()));
306

307
		instantiationService.stub(IFileService, fileService);
308
		instantiationService.stub(IWorkspaceContextService, testObject);
309
		instantiationService.stub(IConfigurationService, testObject);
310
		instantiationService.stub(IEnvironmentService, environmentService);
311

312
		await testObject.initialize(getWorkspaceIdentifier(configResource));
313
		instantiationService.stub(ITextFileService, disposables.add(instantiationService.createInstance(TestTextFileService)));
314
		instantiationService.stub(ITextModelService, disposables.add(instantiationService.createInstance(TextModelResolverService)));
315
		instantiationService.stub(IJSONEditingService, instantiationService.createInstance(JSONEditingService));
316
		testObject.acquireInstantiationService(instantiationService);
317
	});
318

319
	test('add folders', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
320
		await testObject.addFolders([{ uri: joinPath(ROOT, 'd') }, { uri: joinPath(ROOT, 'c') }]);
321
		const actual = testObject.getWorkspace().folders;
322

323
		assert.strictEqual(actual.length, 4);
324
		assert.strictEqual(basename(actual[0].uri), 'a');
325
		assert.strictEqual(basename(actual[1].uri), 'b');
326
		assert.strictEqual(basename(actual[2].uri), 'd');
327
		assert.strictEqual(basename(actual[3].uri), 'c');
328
	}));
329

330
	test('add folders (at specific index)', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
331
		await testObject.addFolders([{ uri: joinPath(ROOT, 'd') }, { uri: joinPath(ROOT, 'c') }], 0);
332
		const actual = testObject.getWorkspace().folders;
333

334
		assert.strictEqual(actual.length, 4);
335
		assert.strictEqual(basename(actual[0].uri), 'd');
336
		assert.strictEqual(basename(actual[1].uri), 'c');
337
		assert.strictEqual(basename(actual[2].uri), 'a');
338
		assert.strictEqual(basename(actual[3].uri), 'b');
339
	}));
340

341
	test('add folders (at specific wrong index)', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
342
		await testObject.addFolders([{ uri: joinPath(ROOT, 'd') }, { uri: joinPath(ROOT, 'c') }], 10);
343
		const actual = testObject.getWorkspace().folders;
344

345
		assert.strictEqual(actual.length, 4);
346
		assert.strictEqual(basename(actual[0].uri), 'a');
347
		assert.strictEqual(basename(actual[1].uri), 'b');
348
		assert.strictEqual(basename(actual[2].uri), 'd');
349
		assert.strictEqual(basename(actual[3].uri), 'c');
350
	}));
351

352
	test('add folders (with name)', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
353
		await testObject.addFolders([{ uri: joinPath(ROOT, 'd'), name: 'DDD' }, { uri: joinPath(ROOT, 'c'), name: 'CCC' }]);
354
		const actual = testObject.getWorkspace().folders;
355

356
		assert.strictEqual(actual.length, 4);
357
		assert.strictEqual(basename(actual[0].uri), 'a');
358
		assert.strictEqual(basename(actual[1].uri), 'b');
359
		assert.strictEqual(basename(actual[2].uri), 'd');
360
		assert.strictEqual(basename(actual[3].uri), 'c');
361
		assert.strictEqual(actual[2].name, 'DDD');
362
		assert.strictEqual(actual[3].name, 'CCC');
363
	}));
364

365
	test('add folders triggers change event', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
366
		const target = sinon.spy();
367
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
368
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
369

370
		const addedFolders = [{ uri: joinPath(ROOT, 'd') }, { uri: joinPath(ROOT, 'c') }];
371
		await testObject.addFolders(addedFolders);
372

373
		assert.strictEqual(target.callCount, 2, `Should be called only once but called ${target.callCount} times`);
374
		const actual_1 = (<IWorkspaceFoldersChangeEvent>target.args[1][0]);
375
		assert.deepStrictEqual(actual_1.added.map(r => r.uri.toString()), addedFolders.map(a => a.uri.toString()));
376
		assert.deepStrictEqual(actual_1.removed, []);
377
		assert.deepStrictEqual(actual_1.changed, []);
378
	}));
379

380
	test('remove folders', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
381
		await testObject.removeFolders([testObject.getWorkspace().folders[0].uri]);
382
		const actual = testObject.getWorkspace().folders;
383

384
		assert.strictEqual(actual.length, 1);
385
		assert.strictEqual(basename(actual[0].uri), 'b');
386
	}));
387

388
	test('remove folders triggers change event', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
389
		const target = sinon.spy();
390
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
391
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
392
		const removedFolder = testObject.getWorkspace().folders[0];
393
		await testObject.removeFolders([removedFolder.uri]);
394

395
		assert.strictEqual(target.callCount, 2, `Should be called only once but called ${target.callCount} times`);
396
		const actual_1 = (<IWorkspaceFoldersChangeEvent>target.args[1][0]);
397
		assert.deepStrictEqual(actual_1.added, []);
398
		assert.deepStrictEqual(actual_1.removed.map(r => r.uri.toString()), [removedFolder.uri.toString()]);
399
		assert.deepStrictEqual(actual_1.changed.map(c => c.uri.toString()), [testObject.getWorkspace().folders[0].uri.toString()]);
400
	}));
401

402
	test('remove folders and add them back by writing into the file', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
403
		const folders = testObject.getWorkspace().folders;
404
		await testObject.removeFolders([folders[0].uri]);
405

406
		const promise = new Promise<void>((resolve, reject) => {
407
			disposables.add(testObject.onDidChangeWorkspaceFolders(actual => {
408
				try {
409
					assert.deepStrictEqual(actual.added.map(r => r.uri.toString()), [folders[0].uri.toString()]);
410
					resolve();
411
				} catch (error) {
412
					reject(error);
413
				}
414
			}));
415
		});
416

417
		const workspace = { folders: [{ path: folders[0].uri.path }, { path: folders[1].uri.path }] };
418
		await fileService.writeFile(testObject.getWorkspace().configuration!, VSBuffer.fromString(JSON.stringify(workspace, null, '\t')));
419
		await promise;
420
	}));
421

422
	test('update folders (remove last and add to end)', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
423
		const target = sinon.spy();
424
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
425
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
426
		const addedFolders = [{ uri: joinPath(ROOT, 'd') }, { uri: joinPath(ROOT, 'c') }];
427
		const removedFolders = [testObject.getWorkspace().folders[1]].map(f => f.uri);
428
		await testObject.updateFolders(addedFolders, removedFolders);
429

430
		assert.strictEqual(target.callCount, 2, `Should be called only once but called ${target.callCount} times`);
431
		const actual_1 = (<IWorkspaceFoldersChangeEvent>target.args[1][0]);
432
		assert.deepStrictEqual(actual_1.added.map(r => r.uri.toString()), addedFolders.map(a => a.uri.toString()));
433
		assert.deepStrictEqual(actual_1.removed.map(r_1 => r_1.uri.toString()), removedFolders.map(a_1 => a_1.toString()));
434
		assert.deepStrictEqual(actual_1.changed, []);
435
	}));
436

437
	test('update folders (rename first via add and remove)', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
438
		const target = sinon.spy();
439
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
440
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
441
		const addedFolders = [{ uri: joinPath(ROOT, 'a'), name: 'The Folder' }];
442
		const removedFolders = [testObject.getWorkspace().folders[0]].map(f => f.uri);
443
		await testObject.updateFolders(addedFolders, removedFolders, 0);
444

445
		assert.strictEqual(target.callCount, 2, `Should be called only once but called ${target.callCount} times`);
446
		const actual_1 = (<IWorkspaceFoldersChangeEvent>target.args[1][0]);
447
		assert.deepStrictEqual(actual_1.added, []);
448
		assert.deepStrictEqual(actual_1.removed, []);
449
		assert.deepStrictEqual(actual_1.changed.map(r => r.uri.toString()), removedFolders.map(a => a.toString()));
450
	}));
451

452
	test('update folders (remove first and add to end)', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
453
		const target = sinon.spy();
454
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
455
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
456
		const addedFolders = [{ uri: joinPath(ROOT, 'd') }, { uri: joinPath(ROOT, 'c') }];
457
		const removedFolders = [testObject.getWorkspace().folders[0]].map(f => f.uri);
458
		const changedFolders = [testObject.getWorkspace().folders[1]].map(f => f.uri);
459
		await testObject.updateFolders(addedFolders, removedFolders);
460

461
		assert.strictEqual(target.callCount, 2, `Should be called only once but called ${target.callCount} times`);
462
		const actual_1 = (<IWorkspaceFoldersChangeEvent>target.args[1][0]);
463
		assert.deepStrictEqual(actual_1.added.map(r => r.uri.toString()), addedFolders.map(a => a.uri.toString()));
464
		assert.deepStrictEqual(actual_1.removed.map(r_1 => r_1.uri.toString()), removedFolders.map(a_1 => a_1.toString()));
465
		assert.deepStrictEqual(actual_1.changed.map(r_2 => r_2.uri.toString()), changedFolders.map(a_2 => a_2.toString()));
466
	}));
467

468
	test('reorder folders trigger change event', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
469
		const target = sinon.spy();
470
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
471
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
472
		const workspace = { folders: [{ path: testObject.getWorkspace().folders[1].uri.path }, { path: testObject.getWorkspace().folders[0].uri.path }] };
473
		await fileService.writeFile(testObject.getWorkspace().configuration!, VSBuffer.fromString(JSON.stringify(workspace, null, '\t')));
474
		await testObject.reloadConfiguration();
475

476
		assert.strictEqual(target.callCount, 2, `Should be called only once but called ${target.callCount} times`);
477
		const actual_1 = (<IWorkspaceFoldersChangeEvent>target.args[1][0]);
478
		assert.deepStrictEqual(actual_1.added, []);
479
		assert.deepStrictEqual(actual_1.removed, []);
480
		assert.deepStrictEqual(actual_1.changed.map(c => c.uri.toString()), testObject.getWorkspace().folders.map(f => f.uri.toString()).reverse());
481
	}));
482

483
	test('rename folders trigger change event', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
484
		const target = sinon.spy();
485
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
486
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
487
		const workspace = { folders: [{ path: testObject.getWorkspace().folders[0].uri.path, name: '1' }, { path: testObject.getWorkspace().folders[1].uri.path }] };
488
		fileService.writeFile(testObject.getWorkspace().configuration!, VSBuffer.fromString(JSON.stringify(workspace, null, '\t')));
489
		await testObject.reloadConfiguration();
490

491
		assert.strictEqual(target.callCount, 2, `Should be called only once but called ${target.callCount} times`);
492
		const actual_1 = (<IWorkspaceFoldersChangeEvent>target.args[1][0]);
493
		assert.deepStrictEqual(actual_1.added, []);
494
		assert.deepStrictEqual(actual_1.removed, []);
495
		assert.deepStrictEqual(actual_1.changed.map(c => c.uri.toString()), [testObject.getWorkspace().folders[0].uri.toString()]);
496
	}));
497

498
});
499

500
suite('WorkspaceService - Initialization', () => {
501

502
	let configResource: URI, testObject: WorkspaceService, fileService: IFileService, environmentService: BrowserWorkbenchEnvironmentService, userDataProfileService: IUserDataProfileService;
503
	const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
504
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
505

506
	suiteSetup(() => {
507
		configurationRegistry.registerConfiguration({
508
			'id': '_test',
509
			'type': 'object',
510
			'properties': {
511
				'initialization.testSetting1': {
512
					'type': 'string',
513
					'default': 'isSet',
514
					scope: ConfigurationScope.RESOURCE
515
				},
516
				'initialization.testSetting2': {
517
					'type': 'string',
518
					'default': 'isSet',
519
					scope: ConfigurationScope.RESOURCE
520
				}
521
			}
522
		});
523
	});
524

525
	setup(async () => {
526
		const logService = new NullLogService();
527
		fileService = disposables.add(new FileService(logService));
528
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
529
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
530

531
		const appSettingsHome = joinPath(ROOT, 'user');
532
		const folderA = joinPath(ROOT, 'a');
533
		const folderB = joinPath(ROOT, 'b');
534
		configResource = joinPath(ROOT, 'vsctests.code-workspace');
535
		const workspace = { folders: [{ path: folderA.path }, { path: folderB.path }] };
536

537
		await fileService.createFolder(appSettingsHome);
538
		await fileService.createFolder(folderA);
539
		await fileService.createFolder(folderB);
540
		await fileService.writeFile(configResource, VSBuffer.fromString(JSON.stringify(workspace, null, '\t')));
541

542
		const instantiationService = workbenchInstantiationService(undefined, disposables);
543
		environmentService = TestEnvironmentService;
544
		const remoteAgentService = disposables.add(instantiationService.createInstance(RemoteAgentService));
545
		instantiationService.stub(IRemoteAgentService, remoteAgentService);
546
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
547
		const userDataProfilesService = instantiationService.stub(IUserDataProfilesService, disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService)));
548
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
549
		userDataProfileService = instantiationService.stub(IUserDataProfileService, disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile)));
550
		testObject = disposables.add(new WorkspaceService(
551
			{ configurationCache: new ConfigurationCache() },
552
			environmentService,
553
			userDataProfileService,
554
			userDataProfilesService, fileService, remoteAgentService, uriIdentityService, new NullLogService(), new NullPolicyService()));
555
		instantiationService.stub(IFileService, fileService);
556
		instantiationService.stub(IWorkspaceContextService, testObject);
557
		instantiationService.stub(IConfigurationService, testObject);
558
		instantiationService.stub(IEnvironmentService, environmentService);
559

560
		await testObject.initialize({ id: '' });
561
		instantiationService.stub(ITextFileService, disposables.add(instantiationService.createInstance(TestTextFileService)));
562
		instantiationService.stub(ITextModelService, disposables.add(instantiationService.createInstance(TextModelResolverService)));
563
		testObject.acquireInstantiationService(instantiationService);
564
	});
565

566
	(isMacintosh ? test.skip : test)('initialize a folder workspace from an empty workspace with no configuration changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
567

568
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "initialization.testSetting1": "userValue" }'));
569

570
		await testObject.reloadConfiguration();
571
		const target = sinon.spy();
572
		disposables.add(testObject.onDidChangeWorkbenchState(target));
573
		disposables.add(testObject.onDidChangeWorkspaceName(target));
574
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
575
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
576
		disposables.add(testObject.onDidChangeConfiguration(target));
577

578
		const folder = joinPath(ROOT, 'a');
579
		await testObject.initialize(convertToWorkspacePayload(folder));
580

581
		assert.strictEqual(testObject.getValue('initialization.testSetting1'), 'userValue');
582
		assert.strictEqual(target.callCount, 4);
583
		assert.deepStrictEqual(target.args[0], [WorkbenchState.FOLDER]);
584
		assert.deepStrictEqual(target.args[1], [undefined]);
585
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[3][0]).added.map(f => f.uri.toString()), [folder.toString()]);
586
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[3][0]).removed, []);
587
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[3][0]).changed, []);
588

589
	}));
590

591
	(isMacintosh ? test.skip : test)('initialize a folder workspace from an empty workspace with configuration changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
592

593
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "initialization.testSetting1": "userValue" }'));
594

595
		await testObject.reloadConfiguration();
596
		const target = sinon.spy();
597
		disposables.add(testObject.onDidChangeWorkbenchState(target));
598
		disposables.add(testObject.onDidChangeWorkspaceName(target));
599
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
600
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
601
		disposables.add(testObject.onDidChangeConfiguration(target));
602

603
		const folder = joinPath(ROOT, 'a');
604
		await fileService.writeFile(joinPath(folder, '.vscode', 'settings.json'), VSBuffer.fromString('{ "initialization.testSetting1": "workspaceValue" }'));
605
		await testObject.initialize(convertToWorkspacePayload(folder));
606

607
		assert.strictEqual(testObject.getValue('initialization.testSetting1'), 'workspaceValue');
608
		assert.strictEqual(target.callCount, 5);
609
		assert.deepStrictEqual([...(<IConfigurationChangeEvent>target.args[0][0]).affectedKeys], ['initialization.testSetting1']);
610
		assert.deepStrictEqual(target.args[1], [WorkbenchState.FOLDER]);
611
		assert.deepStrictEqual(target.args[2], [undefined]);
612
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).added.map(f => f.uri.toString()), [folder.toString()]);
613
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).removed, []);
614
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).changed, []);
615

616
	}));
617

618
	(isMacintosh ? test.skip : test)('initialize a multi root workspace from an empty workspace with no configuration changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
619

620
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "initialization.testSetting1": "userValue" }'));
621

622
		await testObject.reloadConfiguration();
623
		const target = sinon.spy();
624
		disposables.add(testObject.onDidChangeWorkbenchState(target));
625
		disposables.add(testObject.onDidChangeWorkspaceName(target));
626
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
627
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
628
		disposables.add(testObject.onDidChangeConfiguration(target));
629

630
		await testObject.initialize(getWorkspaceIdentifier(configResource));
631

632
		assert.strictEqual(target.callCount, 4);
633
		assert.deepStrictEqual(target.args[0], [WorkbenchState.WORKSPACE]);
634
		assert.deepStrictEqual(target.args[1], [undefined]);
635
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[3][0]).added.map(folder => folder.uri.toString()), [joinPath(ROOT, 'a').toString(), joinPath(ROOT, 'b').toString()]);
636
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[3][0]).removed, []);
637
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[3][0]).changed, []);
638

639
	}));
640

641
	(isMacintosh ? test.skip : test)('initialize a multi root workspace from an empty workspace with configuration changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
642

643
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "initialization.testSetting1": "userValue" }'));
644

645
		await testObject.reloadConfiguration();
646
		const target = sinon.spy();
647
		disposables.add(testObject.onDidChangeWorkbenchState(target));
648
		disposables.add(testObject.onDidChangeWorkspaceName(target));
649
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
650
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
651
		disposables.add(testObject.onDidChangeConfiguration(target));
652

653
		await fileService.writeFile(joinPath(ROOT, 'a', '.vscode', 'settings.json'), VSBuffer.fromString('{ "initialization.testSetting1": "workspaceValue1" }'));
654
		await fileService.writeFile(joinPath(ROOT, 'b', '.vscode', 'settings.json'), VSBuffer.fromString('{ "initialization.testSetting2": "workspaceValue2" }'));
655
		await testObject.initialize(getWorkspaceIdentifier(configResource));
656

657
		assert.strictEqual(target.callCount, 5);
658
		assert.deepStrictEqual([...(<IConfigurationChangeEvent>target.args[0][0]).affectedKeys], ['initialization.testSetting1', 'initialization.testSetting2']);
659
		assert.deepStrictEqual(target.args[1], [WorkbenchState.WORKSPACE]);
660
		assert.deepStrictEqual(target.args[2], [undefined]);
661
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).added.map(folder => folder.uri.toString()), [joinPath(ROOT, 'a').toString(), joinPath(ROOT, 'b').toString()]);
662
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).removed, []);
663
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).changed, []);
664

665
	}));
666

667
	(isMacintosh ? test.skip : test)('initialize a folder workspace from a folder workspace with no configuration changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
668

669
		await testObject.initialize(convertToWorkspacePayload(joinPath(ROOT, 'a')));
670
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "initialization.testSetting1": "userValue" }'));
671
		await testObject.reloadConfiguration();
672
		const target = sinon.spy();
673
		disposables.add(testObject.onDidChangeWorkbenchState(target));
674
		disposables.add(testObject.onDidChangeWorkspaceName(target));
675
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
676
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
677
		disposables.add(testObject.onDidChangeConfiguration(target));
678

679
		await testObject.initialize(convertToWorkspacePayload(joinPath(ROOT, 'b')));
680

681
		assert.strictEqual(testObject.getValue('initialization.testSetting1'), 'userValue');
682
		assert.strictEqual(target.callCount, 2);
683
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[1][0]).added.map(folder_1 => folder_1.uri.toString()), [joinPath(ROOT, 'b').toString()]);
684
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[1][0]).removed.map(folder_2 => folder_2.uri.toString()), [joinPath(ROOT, 'a').toString()]);
685
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[1][0]).changed, []);
686

687
	}));
688

689
	(isMacintosh ? test.skip : test)('initialize a folder workspace from a folder workspace with configuration changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
690

691
		await testObject.initialize(convertToWorkspacePayload(joinPath(ROOT, 'a')));
692
		const target = sinon.spy();
693
		disposables.add(testObject.onDidChangeWorkbenchState(target));
694
		disposables.add(testObject.onDidChangeWorkspaceName(target));
695
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
696
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
697
		disposables.add(testObject.onDidChangeConfiguration(target));
698

699
		await fileService.writeFile(joinPath(ROOT, 'b', '.vscode', 'settings.json'), VSBuffer.fromString('{ "initialization.testSetting1": "workspaceValue2" }'));
700
		await testObject.initialize(convertToWorkspacePayload(joinPath(ROOT, 'b')));
701

702
		assert.strictEqual(testObject.getValue('initialization.testSetting1'), 'workspaceValue2');
703
		assert.strictEqual(target.callCount, 3);
704
		assert.deepStrictEqual([...(<IConfigurationChangeEvent>target.args[0][0]).affectedKeys], ['initialization.testSetting1']);
705
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[2][0]).added.map(folder_1 => folder_1.uri.toString()), [joinPath(ROOT, 'b').toString()]);
706
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[2][0]).removed.map(folder_2 => folder_2.uri.toString()), [joinPath(ROOT, 'a').toString()]);
707
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[2][0]).changed, []);
708

709
	}));
710

711
	(isMacintosh ? test.skip : test)('initialize a multi folder workspace from a folder workspacce triggers change events in the right order', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
712
		await testObject.initialize(convertToWorkspacePayload(joinPath(ROOT, 'a')));
713
		const target = sinon.spy();
714
		disposables.add(testObject.onDidChangeWorkbenchState(target));
715
		disposables.add(testObject.onDidChangeWorkspaceName(target));
716
		disposables.add(testObject.onWillChangeWorkspaceFolders(target));
717
		disposables.add(testObject.onDidChangeWorkspaceFolders(target));
718
		disposables.add(testObject.onDidChangeConfiguration(target));
719

720
		await fileService.writeFile(joinPath(ROOT, 'a', '.vscode', 'settings.json'), VSBuffer.fromString('{ "initialization.testSetting1": "workspaceValue2" }'));
721
		await testObject.initialize(getWorkspaceIdentifier(configResource));
722

723
		assert.strictEqual(target.callCount, 5);
724
		assert.deepStrictEqual([...(<IConfigurationChangeEvent>target.args[0][0]).affectedKeys], ['initialization.testSetting1']);
725
		assert.deepStrictEqual(target.args[1], [WorkbenchState.WORKSPACE]);
726
		assert.deepStrictEqual(target.args[2], [undefined]);
727
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).added.map(folder_1 => folder_1.uri.toString()), [joinPath(ROOT, 'b').toString()]);
728
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).removed, []);
729
		assert.deepStrictEqual((<IWorkspaceFoldersChangeEvent>target.args[4][0]).changed, []);
730
	}));
731

732
});
733

734
suite('WorkspaceConfigurationService - Folder', () => {
735

736
	let testObject: WorkspaceService, workspaceService: WorkspaceService, fileService: IFileService, environmentService: IBrowserWorkbenchEnvironmentService, userDataProfileService: IUserDataProfileService, instantiationService: TestInstantiationService;
737
	const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
738
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
739

740
	suiteSetup(() => {
741
		configurationRegistry.registerConfiguration({
742
			'id': '_test',
743
			'type': 'object',
744
			'properties': {
745
				'configurationService.folder.applicationSetting': {
746
					'type': 'string',
747
					'default': 'isSet',
748
					scope: ConfigurationScope.APPLICATION
749
				},
750
				'configurationService.folder.machineSetting': {
751
					'type': 'string',
752
					'default': 'isSet',
753
					scope: ConfigurationScope.MACHINE
754
				},
755
				'configurationService.folder.applicationMachineSetting': {
756
					'type': 'string',
757
					'default': 'isSet',
758
					scope: ConfigurationScope.APPLICATION_MACHINE
759
				},
760
				'configurationService.folder.machineOverridableSetting': {
761
					'type': 'string',
762
					'default': 'isSet',
763
					scope: ConfigurationScope.MACHINE_OVERRIDABLE
764
				},
765
				'configurationService.folder.testSetting': {
766
					'type': 'string',
767
					'default': 'isSet',
768
					scope: ConfigurationScope.RESOURCE
769
				},
770
				'configurationService.folder.languageSetting': {
771
					'type': 'string',
772
					'default': 'isSet',
773
					scope: ConfigurationScope.LANGUAGE_OVERRIDABLE
774
				},
775
				'configurationService.folder.restrictedSetting': {
776
					'type': 'string',
777
					'default': 'isSet',
778
					restricted: true
779
				},
780
				'configurationService.folder.policySetting': {
781
					'type': 'string',
782
					'default': 'isSet',
783
					policy: {
784
						name: 'configurationService.folder.policySetting',
785
						category: PolicyCategory.Extensions,
786
						minimumVersion: '1.0.0',
787
						localization: { description: { key: '', value: '' } }
788
					}
789
				},
790
				'configurationService.folder.policyObjectSetting': {
791
					'type': 'object',
792
					'default': {},
793
					policy: {
794
						name: 'configurationService.folder.policyObjectSetting',
795
						category: PolicyCategory.Extensions,
796
						minimumVersion: '1.0.0',
797
						localization: { description: { key: '', value: '' } }
798
					}
799
				},
800
			}
801
		});
802

803
		configurationRegistry.registerDefaultConfigurations([{
804
			overrides: {
805
				'[jsonc]': {
806
					'configurationService.folder.languageSetting': 'languageValue'
807
				}
808
			}
809
		}]);
810
	});
811

812
	setup(async () => {
813
		const logService = new NullLogService();
814
		fileService = disposables.add(new FileService(logService));
815
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
816
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
817

818
		const folder = joinPath(ROOT, 'a');
819
		await fileService.createFolder(folder);
820

821
		instantiationService = workbenchInstantiationService(undefined, disposables);
822
		environmentService = TestEnvironmentService;
823
		environmentService.policyFile = joinPath(folder, 'policies.json');
824
		const remoteAgentService = disposables.add(instantiationService.createInstance(RemoteAgentService));
825
		instantiationService.stub(IRemoteAgentService, remoteAgentService);
826
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
827
		const userDataProfilesService = instantiationService.stub(IUserDataProfilesService, disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService)));
828
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
829
		userDataProfileService = instantiationService.stub(IUserDataProfileService, disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile)));
830
		workspaceService = testObject = disposables.add(new WorkspaceService(
831
			{ configurationCache: new ConfigurationCache() },
832
			environmentService, userDataProfileService, userDataProfilesService,
833
			fileService, remoteAgentService, uriIdentityService, new NullLogService(),
834
			disposables.add(new FilePolicyService(environmentService.policyFile, fileService, logService))));
835
		instantiationService.stub(IFileService, fileService);
836
		instantiationService.stub(IWorkspaceContextService, testObject);
837
		instantiationService.stub(IConfigurationService, testObject);
838
		instantiationService.stub(IEnvironmentService, environmentService);
839

840
		await workspaceService.initialize(convertToWorkspacePayload(folder));
841
		instantiationService.stub(IKeybindingEditingService, disposables.add(instantiationService.createInstance(KeybindingsEditingService)));
842
		instantiationService.stub(ITextFileService, disposables.add(instantiationService.createInstance(TestTextFileService)));
843
		instantiationService.stub(ITextModelService, <ITextModelService>disposables.add(instantiationService.createInstance(TextModelResolverService)));
844
		workspaceService.acquireInstantiationService(instantiationService);
845
	});
846

847
	test('defaults', () => {
848
		assert.deepStrictEqual(testObject.getValue('configurationService'),
849
			{
850
				'folder': {
851
					'applicationSetting': 'isSet',
852
					'machineSetting': 'isSet',
853
					'applicationMachineSetting': 'isSet',
854
					'machineOverridableSetting': 'isSet',
855
					'testSetting': 'isSet',
856
					'languageSetting': 'isSet',
857
					'restrictedSetting': 'isSet',
858
					'policySetting': 'isSet',
859
					'policyObjectSetting': {}
860
				}
861
			});
862
	});
863

864
	test('globals override defaults', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
865
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.testSetting": "userValue" }'));
866
		await testObject.reloadConfiguration();
867
		assert.strictEqual(testObject.getValue('configurationService.folder.testSetting'), 'userValue');
868
	}));
869

870
	test('globals', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
871
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "testworkbench.editor.tabs": true }'));
872
		await testObject.reloadConfiguration();
873
		assert.strictEqual(testObject.getValue('testworkbench.editor.tabs'), true);
874
	}));
875

876
	test('workspace settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
877
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "testworkbench.editor.icons": true }'));
878
		await testObject.reloadConfiguration();
879
		assert.strictEqual(testObject.getValue('testworkbench.editor.icons'), true);
880
	}));
881

882
	test('workspace settings override user settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
883
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.testSetting": "userValue" }'));
884
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.testSetting": "workspaceValue" }'));
885
		await testObject.reloadConfiguration();
886
		assert.strictEqual(testObject.getValue('configurationService.folder.testSetting'), 'workspaceValue');
887
	}));
888

889
	test('machine overridable settings override user Settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
890
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.machineOverridableSetting": "userValue" }'));
891
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.machineOverridableSetting": "workspaceValue" }'));
892
		await testObject.reloadConfiguration();
893
		assert.strictEqual(testObject.getValue('configurationService.folder.machineOverridableSetting'), 'workspaceValue');
894
	}));
895

896
	test('workspace settings override user settings after defaults are registered ', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
897
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.newSetting": "userValue" }'));
898
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.newSetting": "workspaceValue" }'));
899
		await testObject.reloadConfiguration();
900
		configurationRegistry.registerConfiguration({
901
			'id': '_test',
902
			'type': 'object',
903
			'properties': {
904
				'configurationService.folder.newSetting': {
905
					'type': 'string',
906
					'default': 'isSet'
907
				}
908
			}
909
		});
910
		assert.strictEqual(testObject.getValue('configurationService.folder.newSetting'), 'workspaceValue');
911
	}));
912

913
	test('machine overridable settings override user settings after defaults are registered ', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
914
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.newMachineOverridableSetting": "userValue" }'));
915
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.newMachineOverridableSetting": "workspaceValue" }'));
916
		await testObject.reloadConfiguration();
917
		configurationRegistry.registerConfiguration({
918
			'id': '_test',
919
			'type': 'object',
920
			'properties': {
921
				'configurationService.folder.newMachineOverridableSetting': {
922
					'type': 'string',
923
					'default': 'isSet',
924
					scope: ConfigurationScope.MACHINE_OVERRIDABLE
925
				}
926
			}
927
		});
928
		assert.strictEqual(testObject.getValue('configurationService.folder.newMachineOverridableSetting'), 'workspaceValue');
929
	}));
930

931
	test('application settings are not read from workspace', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
932
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationSetting": "userValue" }'));
933
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationSetting": "workspaceValue" }'));
934

935
		await testObject.reloadConfiguration();
936

937
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting'), 'userValue');
938
	}));
939

940
	test('application settings are not read from workspace when workspace folder uri is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
941
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationSetting": "userValue" }'));
942
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationSetting": "workspaceValue" }'));
943

944
		await testObject.reloadConfiguration();
945

946
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
947
	}));
948

949
	test('machine settings are not read from workspace', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
950
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.machineSetting": "userValue" }'));
951
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.machineSetting": "workspaceValue" }'));
952

953
		await testObject.reloadConfiguration();
954

955
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
956
	}));
957

958
	test('machine settings are not read from workspace when workspace folder uri is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
959
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.machineSetting": "userValue" }'));
960
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.machineSetting": "workspaceValue" }'));
961

962
		await testObject.reloadConfiguration();
963

964
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
965
	}));
966

967
	test('application machine overridable settings are not read from workspace', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
968
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting": "userValue" }'));
969
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting": "workspaceValue" }'));
970

971
		await testObject.reloadConfiguration();
972

973
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting'), 'userValue');
974
	}));
975

976
	test('application machine overridable settings are not read from workspace when workspace folder uri is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
977
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting": "userValue" }'));
978
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting": "workspaceValue" }'));
979

980
		await testObject.reloadConfiguration();
981

982
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
983
	}));
984

985
	test('get application scope settings are loaded after defaults are registered', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
986
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationSetting-2": "userValue" }'));
987
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationSetting-2": "workspaceValue" }'));
988

989
		await testObject.reloadConfiguration();
990
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting-2'), 'workspaceValue');
991

992
		configurationRegistry.registerConfiguration({
993
			'id': '_test',
994
			'type': 'object',
995
			'properties': {
996
				'configurationService.folder.applicationSetting-2': {
997
					'type': 'string',
998
					'default': 'isSet',
999
					scope: ConfigurationScope.APPLICATION
1000
				}
1001
			}
1002
		});
1003

1004
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting-2'), 'userValue');
1005

1006
		await testObject.reloadConfiguration();
1007
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting-2'), 'userValue');
1008
	}));
1009

1010
	test('get application scope settings are not loaded after defaults are registered when workspace folder uri is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1011
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationSetting-3": "userValue" }'));
1012
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationSetting-3": "workspaceValue" }'));
1013

1014
		await testObject.reloadConfiguration();
1015
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'workspaceValue');
1016

1017
		configurationRegistry.registerConfiguration({
1018
			'id': '_test',
1019
			'type': 'object',
1020
			'properties': {
1021
				'configurationService.folder.applicationSetting-3': {
1022
					'type': 'string',
1023
					'default': 'isSet',
1024
					scope: ConfigurationScope.APPLICATION
1025
				}
1026
			}
1027
		});
1028

1029
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1030

1031
		await testObject.reloadConfiguration();
1032
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1033
	}));
1034

1035
	test('get application machine overridable scope settings are loaded after defaults are registered', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1036
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting-2": "userValue" }'));
1037
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting-2": "workspaceValue" }'));
1038

1039
		await testObject.reloadConfiguration();
1040
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting-2'), 'workspaceValue');
1041

1042
		configurationRegistry.registerConfiguration({
1043
			'id': '_test',
1044
			'type': 'object',
1045
			'properties': {
1046
				'configurationService.folder.applicationMachineSetting-2': {
1047
					'type': 'string',
1048
					'default': 'isSet',
1049
					scope: ConfigurationScope.APPLICATION
1050
				}
1051
			}
1052
		});
1053

1054
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting-2'), 'userValue');
1055

1056
		await testObject.reloadConfiguration();
1057
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting-2'), 'userValue');
1058
	}));
1059

1060
	test('get application machine overridable scope settings are loaded after defaults are registered when workspace folder uri is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1061
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting-3": "userValue" }'));
1062
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.applicationMachineSetting-3": "workspaceValue" }'));
1063

1064
		await testObject.reloadConfiguration();
1065
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'workspaceValue');
1066

1067
		configurationRegistry.registerConfiguration({
1068
			'id': '_test',
1069
			'type': 'object',
1070
			'properties': {
1071
				'configurationService.folder.applicationMachineSetting-3': {
1072
					'type': 'string',
1073
					'default': 'isSet',
1074
					scope: ConfigurationScope.APPLICATION
1075
				}
1076
			}
1077
		});
1078

1079
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1080

1081
		await testObject.reloadConfiguration();
1082
		assert.strictEqual(testObject.getValue('configurationService.folder.applicationMachineSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1083
	}));
1084

1085
	test('get machine scope settings are not loaded after defaults are registered', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1086
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.machineSetting-2": "userValue" }'));
1087
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.machineSetting-2": "workspaceValue" }'));
1088

1089
		await testObject.reloadConfiguration();
1090
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting-2'), 'workspaceValue');
1091

1092
		configurationRegistry.registerConfiguration({
1093
			'id': '_test',
1094
			'type': 'object',
1095
			'properties': {
1096
				'configurationService.folder.machineSetting-2': {
1097
					'type': 'string',
1098
					'default': 'isSet',
1099
					scope: ConfigurationScope.MACHINE
1100
				}
1101
			}
1102
		});
1103

1104
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting-2'), 'userValue');
1105

1106
		await testObject.reloadConfiguration();
1107
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting-2'), 'userValue');
1108
	}));
1109

1110
	test('get machine scope settings are not loaded after defaults are registered when workspace folder uri is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1111
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.machineSetting-3": "userValue" }'));
1112
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.machineSetting-3": "workspaceValue" }'));
1113

1114
		await testObject.reloadConfiguration();
1115
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'workspaceValue');
1116

1117
		configurationRegistry.registerConfiguration({
1118
			'id': '_test',
1119
			'type': 'object',
1120
			'properties': {
1121
				'configurationService.folder.machineSetting-3': {
1122
					'type': 'string',
1123
					'default': 'isSet',
1124
					scope: ConfigurationScope.MACHINE
1125
				}
1126
			}
1127
		});
1128

1129
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1130

1131
		await testObject.reloadConfiguration();
1132
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting-3', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1133
	}));
1134

1135
	test('policy value override all', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1136
		const result = await runWithFakedTimers({ useFakeTimers: true }, async () => {
1137
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1138
			await fileService.writeFile(environmentService.policyFile!, VSBuffer.fromString('{ "configurationService.folder.policySetting": "policyValue" }'));
1139
			return promise;
1140
		});
1141
		assert.deepStrictEqual([...result.affectedKeys], ['configurationService.folder.policySetting']);
1142
		assert.strictEqual(testObject.getValue('configurationService.folder.policySetting'), 'policyValue');
1143
		assert.strictEqual(testObject.inspect('configurationService.folder.policySetting').policyValue, 'policyValue');
1144
	}));
1145

1146
	test('policy settings when policy value is not set', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1147
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.policySetting": "userValue" }'));
1148
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.policySetting": "workspaceValue" }'));
1149
		await testObject.reloadConfiguration();
1150
		assert.strictEqual(testObject.getValue('configurationService.folder.policySetting'), 'workspaceValue');
1151
		assert.strictEqual(testObject.inspect('configurationService.folder.policySetting').policyValue, undefined);
1152
	}));
1153

1154
	test('policy value override all for object type setting', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1155
		await runWithFakedTimers({ useFakeTimers: true }, async () => {
1156
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1157
			await fileService.writeFile(environmentService.policyFile!, VSBuffer.fromString('{ "configurationService.folder.policyObjectSetting": {"a": true} }'));
1158
			return promise;
1159
		});
1160

1161
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.policyObjectSetting": {"b": true} }'));
1162
		await testObject.reloadConfiguration();
1163

1164
		assert.deepStrictEqual(testObject.getValue('configurationService.folder.policyObjectSetting'), { a: true });
1165
	}));
1166

1167
	test('reload configuration emits events after global configuraiton changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1168
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "testworkbench.editor.tabs": true }'));
1169
		const target = sinon.spy();
1170
		disposables.add(testObject.onDidChangeConfiguration(target));
1171
		await testObject.reloadConfiguration();
1172
		assert.ok(target.called);
1173
	}));
1174

1175
	test('reload configuration emits events after workspace configuraiton changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1176
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.testSetting": "workspaceValue" }'));
1177
		const target = sinon.spy();
1178
		disposables.add(testObject.onDidChangeConfiguration(target));
1179
		await testObject.reloadConfiguration();
1180
		assert.ok(target.called);
1181
	}));
1182

1183
	test('reload configuration should not emit event if no changes', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1184
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "testworkbench.editor.tabs": true }'));
1185
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.testSetting": "workspaceValue" }'));
1186
		await testObject.reloadConfiguration();
1187
		const target = sinon.spy();
1188
		disposables.add(testObject.onDidChangeConfiguration(() => { target(); }));
1189
		await testObject.reloadConfiguration();
1190
		assert.ok(!target.called);
1191
	}));
1192

1193
	test('inspect', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1194
		let actual = testObject.inspect('something.missing');
1195
		assert.strictEqual(actual.defaultValue, undefined);
1196
		assert.strictEqual(actual.application, undefined);
1197
		assert.strictEqual(actual.userValue, undefined);
1198
		assert.strictEqual(actual.workspaceValue, undefined);
1199
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1200
		assert.strictEqual(actual.value, undefined);
1201

1202
		actual = testObject.inspect('configurationService.folder.testSetting');
1203
		assert.strictEqual(actual.defaultValue, 'isSet');
1204
		assert.strictEqual(actual.application, undefined);
1205
		assert.strictEqual(actual.userValue, undefined);
1206
		assert.strictEqual(actual.workspaceValue, undefined);
1207
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1208
		assert.strictEqual(actual.value, 'isSet');
1209

1210
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.testSetting": "userValue" }'));
1211
		await testObject.reloadConfiguration();
1212
		actual = testObject.inspect('configurationService.folder.testSetting');
1213
		assert.strictEqual(actual.defaultValue, 'isSet');
1214
		assert.strictEqual(actual.application, undefined);
1215
		assert.strictEqual(actual.userValue, 'userValue');
1216
		assert.strictEqual(actual.workspaceValue, undefined);
1217
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1218
		assert.strictEqual(actual.value, 'userValue');
1219

1220
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.testSetting": "workspaceValue" }'));
1221
		await testObject.reloadConfiguration();
1222
		actual = testObject.inspect('configurationService.folder.testSetting');
1223
		assert.strictEqual(actual.defaultValue, 'isSet');
1224
		assert.strictEqual(actual.application, undefined);
1225
		assert.strictEqual(actual.userValue, 'userValue');
1226
		assert.strictEqual(actual.workspaceValue, 'workspaceValue');
1227
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1228
		assert.strictEqual(actual.value, 'workspaceValue');
1229

1230
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'tasks.json'), VSBuffer.fromString('{ "configurationService.tasks.testSetting": "tasksValue" }'));
1231
		await testObject.reloadConfiguration();
1232
		actual = testObject.inspect('tasks');
1233
		assert.strictEqual(actual.defaultValue, undefined);
1234
		assert.strictEqual(actual.application, undefined);
1235
		assert.deepStrictEqual(actual.userValue, {});
1236
		assert.deepStrictEqual(actual.workspaceValue, {
1237
			'configurationService': {
1238
				'tasks': {
1239
					'testSetting': 'tasksValue'
1240
				}
1241
			}
1242
		});
1243
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1244
		assert.deepStrictEqual(actual.value, {
1245
			'configurationService': {
1246
				'tasks': {
1247
					'testSetting': 'tasksValue'
1248
				}
1249
			}
1250
		});
1251
	}));
1252

1253
	test('inspect restricted settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1254
		testObject.updateWorkspaceTrust(false);
1255
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userRestrictedValue" }'));
1256
		await testObject.reloadConfiguration();
1257
		let actual = testObject.inspect('configurationService.folder.restrictedSetting');
1258
		assert.strictEqual(actual.defaultValue, 'isSet');
1259
		assert.strictEqual(actual.application, undefined);
1260
		assert.strictEqual(actual.userValue, 'userRestrictedValue');
1261
		assert.strictEqual(actual.workspaceValue, undefined);
1262
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1263
		assert.strictEqual(actual.value, 'userRestrictedValue');
1264

1265
		testObject.updateWorkspaceTrust(true);
1266
		await testObject.reloadConfiguration();
1267
		actual = testObject.inspect('configurationService.folder.restrictedSetting');
1268
		assert.strictEqual(actual.defaultValue, 'isSet');
1269
		assert.strictEqual(actual.application, undefined);
1270
		assert.strictEqual(actual.userValue, 'userRestrictedValue');
1271
		assert.strictEqual(actual.workspaceValue, undefined);
1272
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1273
		assert.strictEqual(actual.value, 'userRestrictedValue');
1274

1275
		testObject.updateWorkspaceTrust(false);
1276
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceRestrictedValue" }'));
1277
		await testObject.reloadConfiguration();
1278
		actual = testObject.inspect('configurationService.folder.restrictedSetting');
1279
		assert.strictEqual(actual.defaultValue, 'isSet');
1280
		assert.strictEqual(actual.application, undefined);
1281
		assert.strictEqual(actual.userValue, 'userRestrictedValue');
1282
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
1283
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1284
		assert.strictEqual(actual.value, 'userRestrictedValue');
1285

1286
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'tasks.json'), VSBuffer.fromString('{ "configurationService.tasks.testSetting": "tasksValue" }'));
1287
		await testObject.reloadConfiguration();
1288
		actual = testObject.inspect('tasks');
1289
		assert.strictEqual(actual.defaultValue, undefined);
1290
		assert.strictEqual(actual.application, undefined);
1291
		assert.deepStrictEqual(actual.userValue, {});
1292
		assert.deepStrictEqual(actual.workspaceValue, {
1293
			'configurationService': {
1294
				'tasks': {
1295
					'testSetting': 'tasksValue'
1296
				}
1297
			}
1298
		});
1299
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1300
		assert.deepStrictEqual(actual.value, {
1301
			'configurationService': {
1302
				'tasks': {
1303
					'testSetting': 'tasksValue'
1304
				}
1305
			}
1306
		});
1307

1308
		testObject.updateWorkspaceTrust(true);
1309
		await testObject.reloadConfiguration();
1310
		actual = testObject.inspect('configurationService.folder.restrictedSetting');
1311
		assert.strictEqual(actual.defaultValue, 'isSet');
1312
		assert.strictEqual(actual.application, undefined);
1313
		assert.strictEqual(actual.userValue, 'userRestrictedValue');
1314
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
1315
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1316
		assert.strictEqual(actual.value, 'workspaceRestrictedValue');
1317

1318
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'tasks.json'), VSBuffer.fromString('{ "configurationService.tasks.testSetting": "tasksValue" }'));
1319
		await testObject.reloadConfiguration();
1320
		actual = testObject.inspect('tasks');
1321
		assert.strictEqual(actual.defaultValue, undefined);
1322
		assert.strictEqual(actual.application, undefined);
1323
		assert.deepStrictEqual(actual.userValue, {});
1324
		assert.deepStrictEqual(actual.workspaceValue, {
1325
			'configurationService': {
1326
				'tasks': {
1327
					'testSetting': 'tasksValue'
1328
				}
1329
			}
1330
		});
1331
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1332
		assert.deepStrictEqual(actual.value, {
1333
			'configurationService': {
1334
				'tasks': {
1335
					'testSetting': 'tasksValue'
1336
				}
1337
			}
1338
		});
1339
	}));
1340

1341
	test('inspect restricted settings after change', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1342
		testObject.updateWorkspaceTrust(false);
1343
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userRestrictedValue" }'));
1344
		await testObject.reloadConfiguration();
1345

1346
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1347
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceRestrictedValue" }'));
1348
		const event = await promise;
1349

1350
		const actual = testObject.inspect('configurationService.folder.restrictedSetting');
1351
		assert.strictEqual(actual.defaultValue, 'isSet');
1352
		assert.strictEqual(actual.application, undefined);
1353
		assert.strictEqual(actual.userValue, 'userRestrictedValue');
1354
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
1355
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1356
		assert.strictEqual(actual.value, 'userRestrictedValue');
1357
		assert.strictEqual(event.affectsConfiguration('configurationService.folder.restrictedSetting'), true);
1358
	}));
1359

1360
	test('keys', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1361
		let actual = testObject.keys();
1362
		assert.ok(actual.default.indexOf('configurationService.folder.testSetting') !== -1);
1363
		assert.deepStrictEqual(actual.user, []);
1364
		assert.deepStrictEqual(actual.workspace, []);
1365
		assert.deepStrictEqual(actual.workspaceFolder, []);
1366

1367
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.testSetting": "userValue" }'));
1368
		await testObject.reloadConfiguration();
1369
		actual = testObject.keys();
1370
		assert.ok(actual.default.indexOf('configurationService.folder.testSetting') !== -1);
1371
		assert.deepStrictEqual(actual.user, ['configurationService.folder.testSetting']);
1372
		assert.deepStrictEqual(actual.workspace, []);
1373
		assert.deepStrictEqual(actual.workspaceFolder, []);
1374

1375
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.testSetting": "workspaceValue" }'));
1376
		await testObject.reloadConfiguration();
1377
		actual = testObject.keys();
1378
		assert.ok(actual.default.indexOf('configurationService.folder.testSetting') !== -1);
1379
		assert.deepStrictEqual(actual.user, ['configurationService.folder.testSetting']);
1380
		assert.deepStrictEqual(actual.workspace, ['configurationService.folder.testSetting']);
1381
		assert.deepStrictEqual(actual.workspaceFolder, []);
1382
	}));
1383

1384
	test('update user configuration', () => {
1385
		return testObject.updateValue('configurationService.folder.testSetting', 'value', ConfigurationTarget.USER)
1386
			.then(() => assert.strictEqual(testObject.getValue('configurationService.folder.testSetting'), 'value'));
1387
	});
1388

1389
	test('update workspace configuration', () => {
1390
		return testObject.updateValue('tasks.service.testSetting', 'value', ConfigurationTarget.WORKSPACE)
1391
			.then(() => assert.strictEqual(testObject.getValue(TasksSchemaProperties.ServiceTestSetting), 'value'));
1392
	});
1393

1394
	test('update resource configuration', () => {
1395
		return testObject.updateValue('configurationService.folder.testSetting', 'value', { resource: workspaceService.getWorkspace().folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER)
1396
			.then(() => assert.strictEqual(testObject.getValue('configurationService.folder.testSetting'), 'value'));
1397
	});
1398

1399
	test('update language configuration using configuration overrides', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1400
		await testObject.updateValue('configurationService.folder.languageSetting', 'abcLangValue', { overrideIdentifier: 'abclang' });
1401
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { overrideIdentifier: 'abclang' }), 'abcLangValue');
1402
	}));
1403

1404
	test('update language configuration using configuration update overrides', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1405
		await testObject.updateValue('configurationService.folder.languageSetting', 'abcLangValue', { overrideIdentifiers: ['abclang'] });
1406
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { overrideIdentifier: 'abclang' }), 'abcLangValue');
1407
	}));
1408

1409
	test('update language configuration for multiple languages', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1410
		await testObject.updateValue('configurationService.folder.languageSetting', 'multiLangValue', { overrideIdentifiers: ['xyzlang', 'deflang'] }, ConfigurationTarget.USER);
1411
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { overrideIdentifier: 'deflang' }), 'multiLangValue');
1412
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { overrideIdentifier: 'xyzlang' }), 'multiLangValue');
1413
		assert.deepStrictEqual(testObject.getValue(keyFromOverrideIdentifiers(['deflang', 'xyzlang'])), { 'configurationService.folder.languageSetting': 'multiLangValue' });
1414
	}));
1415

1416
	test('update language configuration for multiple languages when already set', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1417
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "[deflang][xyzlang]": { "configurationService.folder.languageSetting": "userValue" }}'));
1418
		await testObject.updateValue('configurationService.folder.languageSetting', 'multiLangValue', { overrideIdentifiers: ['xyzlang', 'deflang'] }, ConfigurationTarget.USER);
1419
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { overrideIdentifier: 'deflang' }), 'multiLangValue');
1420
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { overrideIdentifier: 'xyzlang' }), 'multiLangValue');
1421
		assert.deepStrictEqual(testObject.getValue(keyFromOverrideIdentifiers(['deflang', 'xyzlang'])), { 'configurationService.folder.languageSetting': 'multiLangValue' });
1422
		const actualContent = (await fileService.readFile(userDataProfileService.currentProfile.settingsResource)).value.toString();
1423
		assert.deepStrictEqual(JSON.parse(actualContent), { '[deflang][xyzlang]': { 'configurationService.folder.languageSetting': 'multiLangValue' } });
1424
	}));
1425

1426
	test('update resource language configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1427
		await testObject.updateValue('configurationService.folder.languageSetting', 'value', { resource: workspaceService.getWorkspace().folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
1428
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting'), 'value');
1429
	}));
1430

1431
	test('update resource language configuration for a language using configuration overrides', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1432
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { resource: workspaceService.getWorkspace().folders[0].uri, overrideIdentifier: 'jsonc' }), 'languageValue');
1433
		await testObject.updateValue('configurationService.folder.languageSetting', 'languageValueUpdated', { resource: workspaceService.getWorkspace().folders[0].uri, overrideIdentifier: 'jsonc' }, ConfigurationTarget.WORKSPACE_FOLDER);
1434
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { resource: workspaceService.getWorkspace().folders[0].uri, overrideIdentifier: 'jsonc' }), 'languageValueUpdated');
1435
	}));
1436

1437
	test('update resource language configuration for a language using configuration update overrides', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1438
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { resource: workspaceService.getWorkspace().folders[0].uri, overrideIdentifier: 'jsonc' }), 'languageValue');
1439
		await testObject.updateValue('configurationService.folder.languageSetting', 'languageValueUpdated', { resource: workspaceService.getWorkspace().folders[0].uri, overrideIdentifiers: ['jsonc'] }, ConfigurationTarget.WORKSPACE_FOLDER);
1440
		assert.strictEqual(testObject.getValue('configurationService.folder.languageSetting', { resource: workspaceService.getWorkspace().folders[0].uri, overrideIdentifier: 'jsonc' }), 'languageValueUpdated');
1441
	}));
1442

1443
	test('update application setting into workspace configuration in a workspace is not supported', () => {
1444
		return testObject.updateValue('configurationService.folder.applicationSetting', 'workspaceValue', {}, ConfigurationTarget.WORKSPACE, { donotNotifyError: true })
1445
			.then(() => assert.fail('Should not be supported'), (e) => assert.strictEqual(e.code, ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_APPLICATION));
1446
	});
1447

1448
	test('update application machine overridable setting into workspace configuration in a workspace is not supported', () => {
1449
		return testObject.updateValue('configurationService.folder.applicationMachineSetting', 'workspaceValue', {}, ConfigurationTarget.WORKSPACE, { donotNotifyError: true })
1450
			.then(() => assert.fail('Should not be supported'), (e) => assert.strictEqual(e.code, ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_APPLICATION));
1451
	});
1452

1453
	test('update machine setting into workspace configuration in a workspace is not supported', () => {
1454
		return testObject.updateValue('configurationService.folder.machineSetting', 'workspaceValue', {}, ConfigurationTarget.WORKSPACE, { donotNotifyError: true })
1455
			.then(() => assert.fail('Should not be supported'), (e) => assert.strictEqual(e.code, ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_MACHINE));
1456
	});
1457

1458
	test('update tasks configuration', () => {
1459
		return testObject.updateValue('tasks', { 'version': '1.0.0', tasks: [{ 'taskName': 'myTask' }] }, ConfigurationTarget.WORKSPACE)
1460
			.then(() => assert.deepStrictEqual(testObject.getValue(TasksSchemaProperties.Tasks), { 'version': '1.0.0', tasks: [{ 'taskName': 'myTask' }] }));
1461
	});
1462

1463
	test('update user configuration should trigger change event before promise is resolve', () => {
1464
		const target = sinon.spy();
1465
		disposables.add(testObject.onDidChangeConfiguration(target));
1466
		return testObject.updateValue('configurationService.folder.testSetting', 'value', ConfigurationTarget.USER)
1467
			.then(() => assert.ok(target.called));
1468
	});
1469

1470
	test('update workspace configuration should trigger change event before promise is resolve', () => {
1471
		const target = sinon.spy();
1472
		disposables.add(testObject.onDidChangeConfiguration(target));
1473
		return testObject.updateValue('configurationService.folder.testSetting', 'value', ConfigurationTarget.WORKSPACE)
1474
			.then(() => assert.ok(target.called));
1475
	});
1476

1477
	test('update memory configuration', () => {
1478
		return testObject.updateValue('configurationService.folder.testSetting', 'memoryValue', ConfigurationTarget.MEMORY)
1479
			.then(() => assert.strictEqual(testObject.getValue('configurationService.folder.testSetting'), 'memoryValue'));
1480
	});
1481

1482
	test('update memory configuration should trigger change event before promise is resolve', () => {
1483
		const target = sinon.spy();
1484
		disposables.add(testObject.onDidChangeConfiguration(target));
1485
		return testObject.updateValue('configurationService.folder.testSetting', 'memoryValue', ConfigurationTarget.MEMORY)
1486
			.then(() => assert.ok(target.called));
1487
	});
1488

1489
	test('remove setting from all targets', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1490
		const key = 'configurationService.folder.testSetting';
1491
		await testObject.updateValue(key, 'workspaceValue', ConfigurationTarget.WORKSPACE);
1492
		await testObject.updateValue(key, 'userValue', ConfigurationTarget.USER);
1493

1494
		await testObject.updateValue(key, undefined);
1495
		await testObject.reloadConfiguration();
1496

1497
		const actual = testObject.inspect(key, { resource: workspaceService.getWorkspace().folders[0].uri });
1498
		assert.strictEqual(actual.userValue, undefined);
1499
		assert.strictEqual(actual.workspaceValue, undefined);
1500
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1501
	}));
1502

1503
	test('update user configuration to default value when target is not passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1504
		await testObject.updateValue('configurationService.folder.testSetting', 'value', ConfigurationTarget.USER);
1505
		await testObject.updateValue('configurationService.folder.testSetting', 'isSet');
1506
		assert.strictEqual(testObject.inspect('configurationService.folder.testSetting').userValue, undefined);
1507
	}));
1508

1509
	test('update user configuration to default value when target is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1510
		await testObject.updateValue('configurationService.folder.testSetting', 'value', ConfigurationTarget.USER);
1511
		await testObject.updateValue('configurationService.folder.testSetting', 'isSet', ConfigurationTarget.USER);
1512
		assert.strictEqual(testObject.inspect('configurationService.folder.testSetting').userValue, 'isSet');
1513
	}));
1514

1515
	test('update task configuration should trigger change event before promise is resolve', () => {
1516
		const target = sinon.spy();
1517
		disposables.add(testObject.onDidChangeConfiguration(target));
1518
		return testObject.updateValue('tasks', { 'version': '1.0.0', tasks: [{ 'taskName': 'myTask' }] }, ConfigurationTarget.WORKSPACE)
1519
			.then(() => assert.ok(target.called));
1520
	});
1521

1522
	test('no change event when there are no global tasks', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1523
		const target = sinon.spy();
1524
		disposables.add(testObject.onDidChangeConfiguration(target));
1525
		await timeout(5);
1526
		assert.ok(target.notCalled);
1527
	}));
1528

1529
	test('change event when there are global tasks', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1530
		await fileService.writeFile(joinPath(environmentService.userRoamingDataHome, 'tasks.json'), VSBuffer.fromString('{ "version": "1.0.0", "tasks": [{ "taskName": "myTask" }'));
1531
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1532
		await testObject.reloadLocalUserConfiguration();
1533
		await promise;
1534
	}));
1535

1536
	test('creating workspace settings', () => runWithFakedTimers({ useFakeTimers: true }, async () => {
1537
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.testSetting": "userValue" }'));
1538
		await testObject.reloadConfiguration();
1539
		await new Promise<void>((c, e) => {
1540
			const disposable = testObject.onDidChangeConfiguration(e => {
1541
				assert.ok(e.affectsConfiguration('configurationService.folder.testSetting'));
1542
				assert.strictEqual(testObject.getValue('configurationService.folder.testSetting'), 'workspaceValue');
1543
				disposable.dispose();
1544
				c();
1545
			});
1546
			fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.testSetting": "workspaceValue" }')).catch(e);
1547
		});
1548
	}));
1549

1550
	test('deleting workspace settings', () => runWithFakedTimers({ useFakeTimers: true }, async () => {
1551
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.testSetting": "userValue" }'));
1552
		const workspaceSettingsResource = joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json');
1553
		await fileService.writeFile(workspaceSettingsResource, VSBuffer.fromString('{ "configurationService.folder.testSetting": "workspaceValue" }'));
1554
		await testObject.reloadConfiguration();
1555
		const e = await new Promise<IConfigurationChangeEvent>((c, e) => {
1556
			Event.once(testObject.onDidChangeConfiguration)(c);
1557
			fileService.del(workspaceSettingsResource).catch(e);
1558
		});
1559
		assert.ok(e.affectsConfiguration('configurationService.folder.testSetting'));
1560
		assert.strictEqual(testObject.getValue('configurationService.folder.testSetting'), 'userValue');
1561
	}));
1562

1563
	test('restricted setting is read from workspace when workspace is trusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1564
		testObject.updateWorkspaceTrust(true);
1565

1566
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userValue" }'));
1567
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceValue" }'));
1568
		await testObject.reloadConfiguration();
1569

1570
		assert.strictEqual(testObject.getValue('configurationService.folder.restrictedSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'workspaceValue');
1571
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.folder.restrictedSetting'));
1572
		assert.strictEqual(testObject.restrictedSettings.userLocal, undefined);
1573
		assert.strictEqual(testObject.restrictedSettings.userRemote, undefined);
1574
		assert.deepStrictEqual(testObject.restrictedSettings.workspace, ['configurationService.folder.restrictedSetting']);
1575
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.size, 1);
1576
		assert.deepStrictEqual(testObject.restrictedSettings.workspaceFolder?.get(workspaceService.getWorkspace().folders[0].uri), ['configurationService.folder.restrictedSetting']);
1577
	}));
1578

1579
	test('restricted setting is not read from workspace when workspace is changed to trusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1580
		testObject.updateWorkspaceTrust(true);
1581

1582
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userValue" }'));
1583
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceValue" }'));
1584
		await testObject.reloadConfiguration();
1585

1586
		testObject.updateWorkspaceTrust(false);
1587

1588
		assert.strictEqual(testObject.getValue('configurationService.folder.restrictedSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1589
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.folder.restrictedSetting'));
1590
		assert.strictEqual(testObject.restrictedSettings.userLocal, undefined);
1591
		assert.strictEqual(testObject.restrictedSettings.userRemote, undefined);
1592
		assert.deepStrictEqual(testObject.restrictedSettings.workspace, ['configurationService.folder.restrictedSetting']);
1593
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.size, 1);
1594
		assert.deepStrictEqual(testObject.restrictedSettings.workspaceFolder?.get(workspaceService.getWorkspace().folders[0].uri), ['configurationService.folder.restrictedSetting']);
1595
	}));
1596

1597
	test('change event is triggered when workspace is changed to untrusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1598
		testObject.updateWorkspaceTrust(true);
1599

1600
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userValue" }'));
1601
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceValue" }'));
1602
		await testObject.reloadConfiguration();
1603

1604
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1605
		testObject.updateWorkspaceTrust(false);
1606

1607
		const event = await promise;
1608
		assert.ok(event.affectedKeys.has('configurationService.folder.restrictedSetting'));
1609
		assert.ok(event.affectsConfiguration('configurationService.folder.restrictedSetting'));
1610
	}));
1611

1612
	test('restricted setting is not read from workspace when workspace is not trusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1613
		testObject.updateWorkspaceTrust(false);
1614

1615
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userValue" }'));
1616
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceValue" }'));
1617
		await testObject.reloadConfiguration();
1618

1619
		assert.strictEqual(testObject.getValue('configurationService.folder.restrictedSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'userValue');
1620
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.folder.restrictedSetting'));
1621
		assert.strictEqual(testObject.restrictedSettings.userLocal, undefined);
1622
		assert.strictEqual(testObject.restrictedSettings.userRemote, undefined);
1623
		assert.deepStrictEqual(testObject.restrictedSettings.workspace, ['configurationService.folder.restrictedSetting']);
1624
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.size, 1);
1625
		assert.deepStrictEqual(testObject.restrictedSettings.workspaceFolder?.get(workspaceService.getWorkspace().folders[0].uri), ['configurationService.folder.restrictedSetting']);
1626
	}));
1627

1628
	test('restricted setting is read when workspace is changed to trusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1629
		testObject.updateWorkspaceTrust(false);
1630

1631
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userValue" }'));
1632
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceValue" }'));
1633
		await testObject.reloadConfiguration();
1634

1635
		testObject.updateWorkspaceTrust(true);
1636

1637
		assert.strictEqual(testObject.getValue('configurationService.folder.restrictedSetting', { resource: workspaceService.getWorkspace().folders[0].uri }), 'workspaceValue');
1638
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.folder.restrictedSetting'));
1639
		assert.strictEqual(testObject.restrictedSettings.userLocal, undefined);
1640
		assert.strictEqual(testObject.restrictedSettings.userRemote, undefined);
1641
		assert.deepStrictEqual(testObject.restrictedSettings.workspace, ['configurationService.folder.restrictedSetting']);
1642
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.size, 1);
1643
		assert.deepStrictEqual(testObject.restrictedSettings.workspaceFolder?.get(workspaceService.getWorkspace().folders[0].uri), ['configurationService.folder.restrictedSetting']);
1644
	}));
1645

1646
	test('change event is triggered when workspace is changed to trusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1647
		testObject.updateWorkspaceTrust(false);
1648

1649
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userValue" }'));
1650
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceValue" }'));
1651
		await testObject.reloadConfiguration();
1652

1653
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1654
		testObject.updateWorkspaceTrust(true);
1655

1656
		const event = await promise;
1657
		assert.ok(event.affectedKeys.has('configurationService.folder.restrictedSetting'));
1658
		assert.ok(event.affectsConfiguration('configurationService.folder.restrictedSetting'));
1659
	}));
1660

1661
	test('adding an restricted setting triggers change event', () => runWithFakedTimers({ useFakeTimers: true }, async () => {
1662
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "userValue" }'));
1663
		testObject.updateWorkspaceTrust(false);
1664

1665
		const promise = Event.toPromise(testObject.onDidChangeRestrictedSettings);
1666
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.restrictedSetting": "workspaceValue" }'));
1667

1668
		return promise;
1669
	}));
1670

1671
	test('remove an unregistered setting', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1672
		const key = 'configurationService.folder.unknownSetting';
1673
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.unknownSetting": "userValue" }'));
1674
		await fileService.writeFile(joinPath(workspaceService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.folder.unknownSetting": "workspaceValue" }'));
1675

1676
		await testObject.reloadConfiguration();
1677
		await testObject.updateValue(key, undefined);
1678

1679
		const actual = testObject.inspect(key, { resource: workspaceService.getWorkspace().folders[0].uri });
1680
		assert.strictEqual(actual.userValue, undefined);
1681
		assert.strictEqual(actual.workspaceValue, undefined);
1682
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1683
	}));
1684
});
1685

1686
suite('WorkspaceConfigurationService - Profiles', () => {
1687

1688
	let testObject: WorkspaceService, workspaceService: WorkspaceService, fileService: IFileService, environmentService: IBrowserWorkbenchEnvironmentService, userDataProfileService: IUserDataProfileService, instantiationService: TestInstantiationService;
1689
	const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
1690
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
1691

1692
	suiteSetup(() => {
1693
		configurationRegistry.registerConfiguration({
1694
			'id': '_test',
1695
			'type': 'object',
1696
			'properties': {
1697
				[APPLY_ALL_PROFILES_SETTING]: {
1698
					'type': 'array',
1699
					'default': [],
1700
					'scope': ConfigurationScope.APPLICATION,
1701
				},
1702
				'configurationService.profiles.applicationSetting': {
1703
					'type': 'string',
1704
					'default': 'isSet',
1705
					scope: ConfigurationScope.APPLICATION
1706
				},
1707
				'configurationService.profiles.applicationMachineSetting': {
1708
					'type': 'string',
1709
					'default': 'isSet',
1710
					scope: ConfigurationScope.APPLICATION_MACHINE
1711
				},
1712
				'configurationService.profiles.testSetting': {
1713
					'type': 'string',
1714
					'default': 'isSet',
1715
				},
1716
				'configurationService.profiles.applicationSetting2': {
1717
					'type': 'string',
1718
					'default': 'isSet',
1719
					scope: ConfigurationScope.APPLICATION
1720
				},
1721
				'configurationService.profiles.testSetting2': {
1722
					'type': 'string',
1723
					'default': 'isSet',
1724
				},
1725
			}
1726
		});
1727
	});
1728

1729
	setup(async () => {
1730
		const logService = new NullLogService();
1731
		fileService = disposables.add(new FileService(logService));
1732
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
1733
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
1734

1735
		const folder = joinPath(ROOT, 'a');
1736
		await fileService.createFolder(folder);
1737

1738
		instantiationService = workbenchInstantiationService(undefined, disposables);
1739
		environmentService = TestEnvironmentService;
1740
		environmentService.policyFile = joinPath(folder, 'policies.json');
1741
		const remoteAgentService = disposables.add(instantiationService.createInstance(RemoteAgentService));
1742
		instantiationService.stub(IRemoteAgentService, remoteAgentService);
1743
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
1744
		const userDataProfilesService = instantiationService.stub(IUserDataProfilesService, disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService)));
1745
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
1746
		userDataProfileService = instantiationService.stub(IUserDataProfileService, disposables.add(new UserDataProfileService(toUserDataProfile('custom', 'custom', joinPath(environmentService.userRoamingDataHome, 'profiles', 'temp'), joinPath(environmentService.cacheHome, 'profilesCache')))));
1747
		workspaceService = testObject = disposables.add(new WorkspaceService(
1748
			{ configurationCache: new ConfigurationCache() },
1749
			environmentService, userDataProfileService, userDataProfilesService,
1750
			fileService, remoteAgentService, uriIdentityService, new NullLogService(),
1751
			disposables.add(new FilePolicyService(environmentService.policyFile, fileService, logService))));
1752
		instantiationService.stub(IFileService, fileService);
1753
		instantiationService.stub(IWorkspaceContextService, testObject);
1754
		instantiationService.stub(IConfigurationService, testObject);
1755
		instantiationService.stub(IEnvironmentService, environmentService);
1756

1757
		await fileService.writeFile(userDataProfilesService.defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting2": "applicationValue", "configurationService.profiles.testSetting2": "userValue" }'));
1758
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting2": "profileValue", "configurationService.profiles.testSetting2": "profileValue" }'));
1759
		await workspaceService.initialize(convertToWorkspacePayload(folder));
1760
		instantiationService.stub(IKeybindingEditingService, disposables.add(instantiationService.createInstance(KeybindingsEditingService)));
1761
		instantiationService.stub(ITextFileService, disposables.add(instantiationService.createInstance(TestTextFileService)));
1762
		instantiationService.stub(ITextModelService, disposables.add(instantiationService.createInstance(TextModelResolverService)));
1763
		workspaceService.acquireInstantiationService(instantiationService);
1764
	});
1765

1766
	test('initialize', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1767
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting2'), 'applicationValue');
1768
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting2'), 'profileValue');
1769
	}));
1770

1771
	test('inspect', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1772
		let actual = testObject.inspect('something.missing');
1773
		assert.strictEqual(actual.defaultValue, undefined);
1774
		assert.strictEqual(actual.application, undefined);
1775
		assert.strictEqual(actual.userValue, undefined);
1776
		assert.strictEqual(actual.workspaceValue, undefined);
1777
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1778
		assert.strictEqual(actual.value, undefined);
1779

1780
		actual = testObject.inspect('configurationService.profiles.applicationSetting');
1781
		assert.strictEqual(actual.defaultValue, 'isSet');
1782
		assert.strictEqual(actual.application, undefined);
1783
		assert.strictEqual(actual.userValue, undefined);
1784
		assert.strictEqual(actual.workspaceValue, undefined);
1785
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1786
		assert.strictEqual(actual.value, 'isSet');
1787

1788
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "applicationValue" }'));
1789
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "profileValue" }'));
1790
		await testObject.reloadConfiguration();
1791
		actual = testObject.inspect('configurationService.profiles.applicationSetting');
1792
		assert.strictEqual(actual.defaultValue, 'isSet');
1793
		assert.strictEqual(actual.applicationValue, 'applicationValue');
1794
		assert.strictEqual(actual.userValue, 'profileValue');
1795
		assert.strictEqual(actual.workspaceValue, undefined);
1796
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1797
		assert.strictEqual(actual.value, 'applicationValue');
1798

1799
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.testSetting": "applicationValue" }'));
1800
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.testSetting": "profileValue" }'));
1801
		await testObject.reloadConfiguration();
1802
		actual = testObject.inspect('configurationService.profiles.testSetting');
1803
		assert.strictEqual(actual.defaultValue, 'isSet');
1804
		assert.strictEqual(actual.applicationValue, undefined);
1805
		assert.strictEqual(actual.userValue, 'profileValue');
1806
		assert.strictEqual(actual.workspaceValue, undefined);
1807
		assert.strictEqual(actual.workspaceFolderValue, undefined);
1808
		assert.strictEqual(actual.value, 'profileValue');
1809
	}));
1810

1811
	test('update application scope setting', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1812
		await testObject.updateValue('configurationService.profiles.applicationSetting', 'applicationValue');
1813

1814
		assert.deepStrictEqual(JSON.parse((await fileService.readFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource)).value.toString()), { 'configurationService.profiles.applicationSetting': 'applicationValue', 'configurationService.profiles.applicationSetting2': 'applicationValue', 'configurationService.profiles.testSetting2': 'userValue' });
1815
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting'), 'applicationValue');
1816
	}));
1817

1818
	test('update application machine setting', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1819
		await testObject.updateValue('configurationService.profiles.applicationMachineSetting', 'applicationValue');
1820

1821
		assert.deepStrictEqual(JSON.parse((await fileService.readFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource)).value.toString()), { 'configurationService.profiles.applicationMachineSetting': 'applicationValue', 'configurationService.profiles.applicationSetting2': 'applicationValue', 'configurationService.profiles.testSetting2': 'userValue' });
1822
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationMachineSetting'), 'applicationValue');
1823
	}));
1824

1825
	test('update normal setting', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1826
		await testObject.updateValue('configurationService.profiles.testSetting', 'profileValue');
1827

1828
		assert.deepStrictEqual(JSON.parse((await fileService.readFile(userDataProfileService.currentProfile.settingsResource)).value.toString()), { 'configurationService.profiles.testSetting': 'profileValue', 'configurationService.profiles.testSetting2': 'profileValue', 'configurationService.profiles.applicationSetting2': 'profileValue' });
1829
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting'), 'profileValue');
1830
	}));
1831

1832
	test('registering normal setting after init', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1833
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.testSetting3": "defaultProfile" }'));
1834
		await testObject.reloadConfiguration();
1835

1836
		configurationRegistry.registerConfiguration({
1837
			'id': '_test',
1838
			'type': 'object',
1839
			'properties': {
1840
				'configurationService.profiles.testSetting3': {
1841
					'type': 'string',
1842
					'default': 'isSet',
1843
				}
1844
			}
1845
		});
1846

1847
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting3'), 'isSet');
1848
	}));
1849

1850
	test('registering application scope setting after init', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1851
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting3": "defaultProfile" }'));
1852
		await testObject.reloadConfiguration();
1853

1854
		configurationRegistry.registerConfiguration({
1855
			'id': '_test',
1856
			'type': 'object',
1857
			'properties': {
1858
				'configurationService.profiles.applicationSetting3': {
1859
					'type': 'string',
1860
					'default': 'isSet',
1861
					scope: ConfigurationScope.APPLICATION
1862
				}
1863
			}
1864
		});
1865

1866
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting3'), 'defaultProfile');
1867
	}));
1868

1869
	test('non registering setting should not be read from default profile', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1870
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.nonregistered": "defaultProfile" }'));
1871
		await testObject.reloadConfiguration();
1872
		assert.strictEqual(testObject.getValue('configurationService.profiles.nonregistered'), undefined);
1873
	}));
1874

1875
	test('initialize with custom all profiles settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1876
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting2'], ConfigurationTarget.USER_LOCAL);
1877

1878
		await testObject.initialize(convertToWorkspacePayload(joinPath(ROOT, 'a')));
1879

1880
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting2'), 'applicationValue');
1881
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting2'), 'userValue');
1882
	}));
1883

1884
	test('update all profiles settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1885
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1886
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting2'], ConfigurationTarget.USER_LOCAL);
1887

1888
		const changeEvent = await promise;
1889
		assert.deepStrictEqual([...changeEvent.affectedKeys], [APPLY_ALL_PROFILES_SETTING, 'configurationService.profiles.testSetting2']);
1890
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting2'), 'userValue');
1891
	}));
1892

1893
	test('setting applied to all profiles is registered later', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1894
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.testSetting4": "userValue" }'));
1895
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.testSetting4": "profileValue" }'));
1896
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting4'], ConfigurationTarget.USER_LOCAL);
1897
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting4'), 'userValue');
1898

1899
		configurationRegistry.registerConfiguration({
1900
			'id': '_test',
1901
			'type': 'object',
1902
			'properties': {
1903
				'configurationService.profiles.testSetting4': {
1904
					'type': 'string',
1905
					'default': 'isSet',
1906
				}
1907
			}
1908
		});
1909

1910
		await testObject.reloadConfiguration();
1911
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting4'), 'userValue');
1912
	}));
1913

1914
	test('update setting that is applied to all profiles', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1915
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting2'], ConfigurationTarget.USER_LOCAL);
1916
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1917
		await testObject.updateValue('configurationService.profiles.testSetting2', 'updatedValue', ConfigurationTarget.USER_LOCAL);
1918

1919
		const changeEvent = await promise;
1920
		assert.deepStrictEqual([...changeEvent.affectedKeys], ['configurationService.profiles.testSetting2']);
1921
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting2'), 'updatedValue');
1922
	}));
1923

1924
	test('test isSettingAppliedToAllProfiles', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1925
		assert.strictEqual(testObject.isSettingAppliedForAllProfiles('configurationService.profiles.applicationSetting2'), true);
1926
		assert.strictEqual(testObject.isSettingAppliedForAllProfiles('configurationService.profiles.testSetting2'), false);
1927

1928
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting2'], ConfigurationTarget.USER_LOCAL);
1929
		assert.strictEqual(testObject.isSettingAppliedForAllProfiles('configurationService.profiles.testSetting2'), true);
1930
	}));
1931

1932
	test('switch to default profile', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1933
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "applicationValue", "configurationService.profiles.testSetting": "userValue" }'));
1934
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "profileValue", "configurationService.profiles.testSetting": "profileValue" }'));
1935
		await testObject.reloadConfiguration();
1936

1937
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1938
		await userDataProfileService.updateCurrentProfile(instantiationService.get(IUserDataProfilesService).defaultProfile);
1939

1940
		const changeEvent = await promise;
1941
		assert.deepStrictEqual([...changeEvent.affectedKeys], ['configurationService.profiles.testSetting']);
1942
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting'), 'applicationValue');
1943
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting'), 'userValue');
1944
	}));
1945

1946
	test('switch to non default profile', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1947
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "applicationValue", "configurationService.profiles.testSetting": "userValue" }'));
1948
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "profileValue", "configurationService.profiles.testSetting": "profileValue" }'));
1949
		await testObject.reloadConfiguration();
1950

1951
		const profile = toUserDataProfile('custom2', 'custom2', joinPath(environmentService.userRoamingDataHome, 'profiles', 'custom2'), joinPath(environmentService.cacheHome, 'profilesCache'));
1952
		await fileService.writeFile(profile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "profileValue2", "configurationService.profiles.testSetting": "profileValue2" }'));
1953
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1954
		await userDataProfileService.updateCurrentProfile(profile);
1955

1956
		const changeEvent = await promise;
1957
		assert.deepStrictEqual([...changeEvent.affectedKeys], ['configurationService.profiles.testSetting']);
1958
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting'), 'applicationValue');
1959
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting'), 'profileValue2');
1960
	}));
1961

1962
	test('switch to non default profile using settings from default profile', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1963
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "applicationValue", "configurationService.profiles.testSetting": "userValue" }'));
1964
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "profileValue", "configurationService.profiles.testSetting": "profileValue" }'));
1965
		await testObject.reloadConfiguration();
1966

1967
		const profile = toUserDataProfile('custom3', 'custom3', joinPath(environmentService.userRoamingDataHome, 'profiles', 'custom2'), joinPath(environmentService.cacheHome, 'profilesCache'), { useDefaultFlags: { settings: true } }, instantiationService.get(IUserDataProfilesService).defaultProfile);
1968
		await fileService.writeFile(profile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "applicationValue2", "configurationService.profiles.testSetting": "profileValue2" }'));
1969
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1970
		await userDataProfileService.updateCurrentProfile(profile);
1971

1972
		const changeEvent = await promise;
1973
		assert.deepStrictEqual([...changeEvent.affectedKeys], ['configurationService.profiles.applicationSetting', 'configurationService.profiles.testSetting']);
1974
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting'), 'applicationValue2');
1975
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting'), 'profileValue2');
1976
	}));
1977

1978
	test('In non-default profile, changing application settings shall include only application scope settings in the change event', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1979
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{}'));
1980
		await testObject.reloadConfiguration();
1981

1982
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
1983
		await fileService.writeFile(instantiationService.get(IUserDataProfilesService).defaultProfile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.applicationSetting": "applicationValue", "configurationService.profiles.testSetting": "applicationValue" }'));
1984

1985
		const changeEvent = await promise;
1986
		assert.deepStrictEqual([...changeEvent.affectedKeys], ['configurationService.profiles.applicationSetting']);
1987
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting'), 'applicationValue');
1988
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting'), 'isSet');
1989
	}));
1990

1991
	test('switch to default profile with settings applied to all profiles', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
1992
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting2'], ConfigurationTarget.USER_LOCAL);
1993

1994
		await userDataProfileService.updateCurrentProfile(instantiationService.get(IUserDataProfilesService).defaultProfile);
1995

1996
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting2'), 'applicationValue');
1997
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting2'), 'userValue');
1998
	}));
1999

2000
	test('switch to non default profile with settings applied to all profiles', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2001
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting2'], ConfigurationTarget.USER_LOCAL);
2002

2003
		const profile = toUserDataProfile('custom2', 'custom2', joinPath(environmentService.userRoamingDataHome, 'profiles', 'custom2'), joinPath(environmentService.cacheHome, 'profilesCache'));
2004
		await fileService.writeFile(profile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.testSetting": "profileValue", "configurationService.profiles.testSetting2": "profileValue2" }'));
2005
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
2006
		await userDataProfileService.updateCurrentProfile(profile);
2007

2008
		const changeEvent = await promise;
2009
		assert.deepStrictEqual([...changeEvent.affectedKeys], ['configurationService.profiles.testSetting']);
2010
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting2'), 'applicationValue');
2011
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting2'), 'userValue');
2012
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting'), 'profileValue');
2013
	}));
2014

2015
	test('switch to non default from default profile with settings applied to all profiles', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2016
		await testObject.updateValue(APPLY_ALL_PROFILES_SETTING, ['configurationService.profiles.testSetting2'], ConfigurationTarget.USER_LOCAL);
2017
		await userDataProfileService.updateCurrentProfile(instantiationService.get(IUserDataProfilesService).defaultProfile);
2018

2019
		const profile = toUserDataProfile('custom2', 'custom2', joinPath(environmentService.userRoamingDataHome, 'profiles', 'custom2'), joinPath(environmentService.cacheHome, 'profilesCache'));
2020
		await fileService.writeFile(profile.settingsResource, VSBuffer.fromString('{ "configurationService.profiles.testSetting": "profileValue", "configurationService.profiles.testSetting2": "profileValue2" }'));
2021
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
2022
		await userDataProfileService.updateCurrentProfile(profile);
2023

2024
		const changeEvent = await promise;
2025
		assert.deepStrictEqual([...changeEvent.affectedKeys], ['configurationService.profiles.testSetting']);
2026
		assert.strictEqual(testObject.getValue('configurationService.profiles.applicationSetting2'), 'applicationValue');
2027
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting2'), 'userValue');
2028
		assert.strictEqual(testObject.getValue('configurationService.profiles.testSetting'), 'profileValue');
2029
	}));
2030

2031
});
2032

2033
suite('WorkspaceConfigurationService-Multiroot', () => {
2034

2035
	let workspaceContextService: IWorkspaceContextService, jsonEditingServce: IJSONEditingService, testObject: WorkspaceService, fileService: IFileService, environmentService: BrowserWorkbenchEnvironmentService, userDataProfileService: IUserDataProfileService;
2036
	const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
2037
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
2038

2039
	suiteSetup(() => {
2040
		configurationRegistry.registerConfiguration({
2041
			'id': '_test',
2042
			'type': 'object',
2043
			'properties': {
2044
				'configurationService.workspace.testSetting': {
2045
					'type': 'string',
2046
					'default': 'isSet'
2047
				},
2048
				'configurationService.workspace.applicationSetting': {
2049
					'type': 'string',
2050
					'default': 'isSet',
2051
					scope: ConfigurationScope.APPLICATION
2052
				},
2053
				'configurationService.workspace.machineSetting': {
2054
					'type': 'string',
2055
					'default': 'isSet',
2056
					scope: ConfigurationScope.MACHINE
2057
				},
2058
				'configurationService.workspace.machineOverridableSetting': {
2059
					'type': 'string',
2060
					'default': 'isSet',
2061
					scope: ConfigurationScope.MACHINE_OVERRIDABLE
2062
				},
2063
				'configurationService.workspace.testResourceSetting': {
2064
					'type': 'string',
2065
					'default': 'isSet',
2066
					scope: ConfigurationScope.RESOURCE
2067
				},
2068
				'configurationService.workspace.testLanguageSetting': {
2069
					'type': 'string',
2070
					'default': 'isSet',
2071
					scope: ConfigurationScope.LANGUAGE_OVERRIDABLE
2072
				},
2073
				'configurationService.workspace.testRestrictedSetting1': {
2074
					'type': 'string',
2075
					'default': 'isSet',
2076
					restricted: true,
2077
					scope: ConfigurationScope.RESOURCE
2078
				},
2079
				'configurationService.workspace.testRestrictedSetting2': {
2080
					'type': 'string',
2081
					'default': 'isSet',
2082
					restricted: true,
2083
					scope: ConfigurationScope.RESOURCE
2084
				}
2085
			}
2086
		});
2087
	});
2088

2089
	setup(async () => {
2090
		const logService = new NullLogService();
2091
		fileService = disposables.add(new FileService(logService));
2092
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
2093
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
2094

2095
		const appSettingsHome = joinPath(ROOT, 'user');
2096
		const folderA = joinPath(ROOT, 'a');
2097
		const folderB = joinPath(ROOT, 'b');
2098
		const configResource = joinPath(ROOT, 'vsctests.code-workspace');
2099
		const workspace = { folders: [{ path: folderA.path }, { path: folderB.path }] };
2100

2101
		await fileService.createFolder(appSettingsHome);
2102
		await fileService.createFolder(folderA);
2103
		await fileService.createFolder(folderB);
2104
		await fileService.writeFile(configResource, VSBuffer.fromString(JSON.stringify(workspace, null, '\t')));
2105

2106
		const instantiationService = workbenchInstantiationService(undefined, disposables);
2107
		environmentService = TestEnvironmentService;
2108
		const remoteAgentService = disposables.add(instantiationService.createInstance(RemoteAgentService));
2109
		instantiationService.stub(IRemoteAgentService, remoteAgentService);
2110
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
2111
		const userDataProfilesService = instantiationService.stub(IUserDataProfilesService, disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService)));
2112
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
2113
		userDataProfileService = instantiationService.stub(IUserDataProfileService, disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile)));
2114
		const workspaceService = disposables.add(new WorkspaceService(
2115
			{ configurationCache: new ConfigurationCache() },
2116
			environmentService, userDataProfileService, userDataProfilesService,
2117
			fileService, remoteAgentService, uriIdentityService, new NullLogService(), new NullPolicyService()));
2118

2119
		instantiationService.stub(IFileService, fileService);
2120
		instantiationService.stub(IWorkspaceContextService, workspaceService);
2121
		instantiationService.stub(IConfigurationService, workspaceService);
2122
		instantiationService.stub(IWorkbenchEnvironmentService, environmentService);
2123
		instantiationService.stub(IEnvironmentService, environmentService);
2124

2125
		await workspaceService.initialize(getWorkspaceIdentifier(configResource));
2126
		instantiationService.stub(IKeybindingEditingService, disposables.add(instantiationService.createInstance(KeybindingsEditingService)));
2127
		instantiationService.stub(ITextFileService, disposables.add(instantiationService.createInstance(TestTextFileService)));
2128
		instantiationService.stub(ITextModelService, disposables.add(instantiationService.createInstance(TextModelResolverService)));
2129
		jsonEditingServce = instantiationService.createInstance(JSONEditingService);
2130
		instantiationService.stub(IJSONEditingService, jsonEditingServce);
2131
		workspaceService.acquireInstantiationService(instantiationService);
2132

2133
		workspaceContextService = workspaceService;
2134
		testObject = workspaceService;
2135
	});
2136

2137
	test('application settings are not read from workspace', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2138
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.applicationSetting": "userValue" }'));
2139
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['settings'], value: { 'configurationService.workspace.applicationSetting': 'workspaceValue' } }], true);
2140

2141
		await testObject.reloadConfiguration();
2142

2143
		assert.strictEqual(testObject.getValue('configurationService.workspace.applicationSetting'), 'userValue');
2144
	}));
2145

2146
	test('application settings are not read from workspace when folder is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2147
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.applicationSetting": "userValue" }'));
2148
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['settings'], value: { 'configurationService.workspace.applicationSetting': 'workspaceValue' } }], true);
2149

2150
		await testObject.reloadConfiguration();
2151

2152
		assert.strictEqual(testObject.getValue('configurationService.workspace.applicationSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2153
	}));
2154

2155
	test('machine settings are not read from workspace', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2156
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.machineSetting": "userValue" }'));
2157
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['settings'], value: { 'configurationService.workspace.machineSetting': 'workspaceValue' } }], true);
2158

2159
		await testObject.reloadConfiguration();
2160

2161
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting'), 'userValue');
2162
	}));
2163

2164
	test('machine settings are not read from workspace when folder is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2165
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.folder.machineSetting": "userValue" }'));
2166
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['settings'], value: { 'configurationService.workspace.machineSetting': 'workspaceValue' } }], true);
2167

2168
		await testObject.reloadConfiguration();
2169

2170
		assert.strictEqual(testObject.getValue('configurationService.folder.machineSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2171
	}));
2172

2173
	test('get application scope settings are not loaded after defaults are registered', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2174
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.newSetting": "userValue" }'));
2175
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['settings'], value: { 'configurationService.workspace.newSetting': 'workspaceValue' } }], true);
2176

2177
		await testObject.reloadConfiguration();
2178
		assert.strictEqual(testObject.getValue('configurationService.workspace.newSetting'), 'workspaceValue');
2179

2180
		configurationRegistry.registerConfiguration({
2181
			'id': '_test',
2182
			'type': 'object',
2183
			'properties': {
2184
				'configurationService.workspace.newSetting': {
2185
					'type': 'string',
2186
					'default': 'isSet',
2187
					scope: ConfigurationScope.APPLICATION
2188
				}
2189
			}
2190
		});
2191

2192
		assert.strictEqual(testObject.getValue('configurationService.workspace.newSetting'), 'userValue');
2193

2194
		await testObject.reloadConfiguration();
2195
		assert.strictEqual(testObject.getValue('configurationService.workspace.newSetting'), 'userValue');
2196
	}));
2197

2198
	test('get application scope settings are not loaded after defaults are registered when workspace folder is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2199
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.newSetting-2": "userValue" }'));
2200
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['settings'], value: { 'configurationService.workspace.newSetting-2': 'workspaceValue' } }], true);
2201

2202
		await testObject.reloadConfiguration();
2203
		assert.strictEqual(testObject.getValue('configurationService.workspace.newSetting-2', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'workspaceValue');
2204

2205
		configurationRegistry.registerConfiguration({
2206
			'id': '_test',
2207
			'type': 'object',
2208
			'properties': {
2209
				'configurationService.workspace.newSetting-2': {
2210
					'type': 'string',
2211
					'default': 'isSet',
2212
					scope: ConfigurationScope.APPLICATION
2213
				}
2214
			}
2215
		});
2216

2217
		assert.strictEqual(testObject.getValue('configurationService.workspace.newSetting-2', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2218

2219
		await testObject.reloadConfiguration();
2220
		assert.strictEqual(testObject.getValue('configurationService.workspace.newSetting-2', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2221
	}));
2222

2223
	test('workspace settings override user settings after defaults are registered for machine overridable settings ', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2224
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.newMachineOverridableSetting": "userValue" }'));
2225
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['settings'], value: { 'configurationService.workspace.newMachineOverridableSetting': 'workspaceValue' } }], true);
2226

2227
		await testObject.reloadConfiguration();
2228
		assert.strictEqual(testObject.getValue('configurationService.workspace.newMachineOverridableSetting'), 'workspaceValue');
2229

2230
		configurationRegistry.registerConfiguration({
2231
			'id': '_test',
2232
			'type': 'object',
2233
			'properties': {
2234
				'configurationService.workspace.newMachineOverridableSetting': {
2235
					'type': 'string',
2236
					'default': 'isSet',
2237
					scope: ConfigurationScope.MACHINE_OVERRIDABLE
2238
				}
2239
			}
2240
		});
2241

2242
		assert.strictEqual(testObject.getValue('configurationService.workspace.newMachineOverridableSetting'), 'workspaceValue');
2243

2244
		await testObject.reloadConfiguration();
2245
		assert.strictEqual(testObject.getValue('configurationService.workspace.newMachineOverridableSetting'), 'workspaceValue');
2246

2247
	}));
2248

2249
	test('application settings are not read from workspace folder', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2250
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.applicationSetting": "userValue" }'));
2251
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.applicationSetting": "workspaceFolderValue" }'));
2252

2253
		await testObject.reloadConfiguration();
2254

2255
		assert.strictEqual(testObject.getValue('configurationService.workspace.applicationSetting'), 'userValue');
2256
	}));
2257

2258
	test('application settings are not read from workspace folder when workspace folder is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2259
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.applicationSetting": "userValue" }'));
2260
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.applicationSetting": "workspaceFolderValue" }'));
2261

2262
		await testObject.reloadConfiguration();
2263

2264
		assert.strictEqual(testObject.getValue('configurationService.workspace.applicationSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2265
	}));
2266

2267
	test('machine settings are not read from workspace folder', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2268
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.machineSetting": "userValue" }'));
2269
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.machineSetting": "workspaceFolderValue" }'));
2270

2271
		await testObject.reloadConfiguration();
2272

2273
		assert.strictEqual(testObject.getValue('configurationService.workspace.machineSetting'), 'userValue');
2274
	}));
2275

2276
	test('machine settings are not read from workspace folder when workspace folder is passed', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2277
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.machineSetting": "userValue" }'));
2278
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.machineSetting": "workspaceFolderValue" }'));
2279

2280
		await testObject.reloadConfiguration();
2281

2282
		assert.strictEqual(testObject.getValue('configurationService.workspace.machineSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2283
	}));
2284

2285
	test('application settings are not read from workspace folder after defaults are registered', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2286
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.testNewApplicationSetting": "userValue" }'));
2287
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testNewApplicationSetting": "workspaceFolderValue" }'));
2288

2289
		await testObject.reloadConfiguration();
2290
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewApplicationSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'workspaceFolderValue');
2291

2292
		configurationRegistry.registerConfiguration({
2293
			'id': '_test',
2294
			'type': 'object',
2295
			'properties': {
2296
				'configurationService.workspace.testNewApplicationSetting': {
2297
					'type': 'string',
2298
					'default': 'isSet',
2299
					scope: ConfigurationScope.APPLICATION
2300
				}
2301
			}
2302
		});
2303

2304
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewApplicationSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2305

2306
		await testObject.reloadConfiguration();
2307
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewApplicationSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2308
	}));
2309

2310
	test('machine settings are not read from workspace folder after defaults are registered', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2311
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.testNewMachineSetting": "userValue" }'));
2312
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testNewMachineSetting": "workspaceFolderValue" }'));
2313
		await testObject.reloadConfiguration();
2314

2315
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewMachineSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'workspaceFolderValue');
2316

2317
		configurationRegistry.registerConfiguration({
2318
			'id': '_test',
2319
			'type': 'object',
2320
			'properties': {
2321
				'configurationService.workspace.testNewMachineSetting': {
2322
					'type': 'string',
2323
					'default': 'isSet',
2324
					scope: ConfigurationScope.MACHINE
2325
				}
2326
			}
2327
		});
2328

2329
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewMachineSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2330

2331
		await testObject.reloadConfiguration();
2332
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewMachineSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'userValue');
2333
	}));
2334

2335
	test('resource setting in folder is read after it is registered later', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2336
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testNewResourceSetting2": "workspaceFolderValue" }'));
2337
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testNewResourceSetting2': 'workspaceValue' } }], true);
2338
		await testObject.reloadConfiguration();
2339
		configurationRegistry.registerConfiguration({
2340
			'id': '_test',
2341
			'type': 'object',
2342
			'properties': {
2343
				'configurationService.workspace.testNewResourceSetting2': {
2344
					'type': 'string',
2345
					'default': 'isSet',
2346
					scope: ConfigurationScope.RESOURCE
2347
				}
2348
			}
2349
		});
2350
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewResourceSetting2', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'workspaceFolderValue');
2351
	}));
2352

2353
	test('resource language setting in folder is read after it is registered later', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2354
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testNewResourceLanguageSetting2": "workspaceFolderValue" }'));
2355
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testNewResourceLanguageSetting2': 'workspaceValue' } }], true);
2356
		await testObject.reloadConfiguration();
2357
		configurationRegistry.registerConfiguration({
2358
			'id': '_test',
2359
			'type': 'object',
2360
			'properties': {
2361
				'configurationService.workspace.testNewResourceLanguageSetting2': {
2362
					'type': 'string',
2363
					'default': 'isSet',
2364
					scope: ConfigurationScope.LANGUAGE_OVERRIDABLE
2365
				}
2366
			}
2367
		});
2368
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewResourceLanguageSetting2', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'workspaceFolderValue');
2369
	}));
2370

2371
	test('machine overridable setting in folder is read after it is registered later', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2372
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testNewMachineOverridableSetting2": "workspaceFolderValue" }'));
2373
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testNewMachineOverridableSetting2': 'workspaceValue' } }], true);
2374
		await testObject.reloadConfiguration();
2375
		configurationRegistry.registerConfiguration({
2376
			'id': '_test',
2377
			'type': 'object',
2378
			'properties': {
2379
				'configurationService.workspace.testNewMachineOverridableSetting2': {
2380
					'type': 'string',
2381
					'default': 'isSet',
2382
					scope: ConfigurationScope.MACHINE_OVERRIDABLE
2383
				}
2384
			}
2385
		});
2386
		assert.strictEqual(testObject.getValue('configurationService.workspace.testNewMachineOverridableSetting2', { resource: workspaceContextService.getWorkspace().folders[0].uri }), 'workspaceFolderValue');
2387
	}));
2388

2389
	test('inspect', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2390
		let actual = testObject.inspect('something.missing');
2391
		assert.strictEqual(actual.defaultValue, undefined);
2392
		assert.strictEqual(actual.userValue, undefined);
2393
		assert.strictEqual(actual.workspaceValue, undefined);
2394
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2395
		assert.strictEqual(actual.value, undefined);
2396

2397
		actual = testObject.inspect('configurationService.workspace.testResourceSetting');
2398
		assert.strictEqual(actual.defaultValue, 'isSet');
2399
		assert.strictEqual(actual.userValue, undefined);
2400
		assert.strictEqual(actual.workspaceValue, undefined);
2401
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2402
		assert.strictEqual(actual.value, 'isSet');
2403

2404
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.testResourceSetting": "userValue" }'));
2405
		await testObject.reloadConfiguration();
2406
		actual = testObject.inspect('configurationService.workspace.testResourceSetting');
2407
		assert.strictEqual(actual.defaultValue, 'isSet');
2408
		assert.strictEqual(actual.userValue, 'userValue');
2409
		assert.strictEqual(actual.workspaceValue, undefined);
2410
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2411
		assert.strictEqual(actual.value, 'userValue');
2412

2413
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testResourceSetting': 'workspaceValue' } }], true);
2414
		await testObject.reloadConfiguration();
2415
		actual = testObject.inspect('configurationService.workspace.testResourceSetting');
2416
		assert.strictEqual(actual.defaultValue, 'isSet');
2417
		assert.strictEqual(actual.userValue, 'userValue');
2418
		assert.strictEqual(actual.workspaceValue, 'workspaceValue');
2419
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2420
		assert.strictEqual(actual.value, 'workspaceValue');
2421

2422
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testResourceSetting": "workspaceFolderValue" }'));
2423
		await testObject.reloadConfiguration();
2424
		actual = testObject.inspect('configurationService.workspace.testResourceSetting', { resource: workspaceContextService.getWorkspace().folders[0].uri });
2425
		assert.strictEqual(actual.defaultValue, 'isSet');
2426
		assert.strictEqual(actual.userValue, 'userValue');
2427
		assert.strictEqual(actual.workspaceValue, 'workspaceValue');
2428
		assert.strictEqual(actual.workspaceFolderValue, 'workspaceFolderValue');
2429
		assert.strictEqual(actual.value, 'workspaceFolderValue');
2430
	}));
2431

2432
	test('inspect restricted settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2433
		testObject.updateWorkspaceTrust(false);
2434
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testRestrictedSetting1': 'workspaceRestrictedValue' } }], true);
2435
		await testObject.reloadConfiguration();
2436
		let actual = testObject.inspect('configurationService.workspace.testRestrictedSetting1', { resource: workspaceContextService.getWorkspace().folders[0].uri });
2437
		assert.strictEqual(actual.defaultValue, 'isSet');
2438
		assert.strictEqual(actual.application, undefined);
2439
		assert.strictEqual(actual.userValue, undefined);
2440
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
2441
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2442
		assert.strictEqual(actual.value, 'isSet');
2443

2444
		testObject.updateWorkspaceTrust(true);
2445
		await testObject.reloadConfiguration();
2446
		actual = testObject.inspect('configurationService.workspace.testRestrictedSetting1', { resource: workspaceContextService.getWorkspace().folders[0].uri });
2447
		assert.strictEqual(actual.defaultValue, 'isSet');
2448
		assert.strictEqual(actual.application, undefined);
2449
		assert.strictEqual(actual.userValue, undefined);
2450
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
2451
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2452
		assert.strictEqual(actual.value, 'workspaceRestrictedValue');
2453

2454
		testObject.updateWorkspaceTrust(false);
2455
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testRestrictedSetting1": "workspaceFolderRestrictedValue" }'));
2456
		await testObject.reloadConfiguration();
2457
		actual = testObject.inspect('configurationService.workspace.testRestrictedSetting1', { resource: workspaceContextService.getWorkspace().folders[0].uri });
2458
		assert.strictEqual(actual.defaultValue, 'isSet');
2459
		assert.strictEqual(actual.application, undefined);
2460
		assert.strictEqual(actual.userValue, undefined);
2461
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
2462
		assert.strictEqual(actual.workspaceFolderValue, 'workspaceFolderRestrictedValue');
2463
		assert.strictEqual(actual.value, 'isSet');
2464

2465
		testObject.updateWorkspaceTrust(true);
2466
		await testObject.reloadConfiguration();
2467
		actual = testObject.inspect('configurationService.workspace.testRestrictedSetting1', { resource: workspaceContextService.getWorkspace().folders[0].uri });
2468
		assert.strictEqual(actual.defaultValue, 'isSet');
2469
		assert.strictEqual(actual.application, undefined);
2470
		assert.strictEqual(actual.userValue, undefined);
2471
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
2472
		assert.strictEqual(actual.workspaceFolderValue, 'workspaceFolderRestrictedValue');
2473
		assert.strictEqual(actual.value, 'workspaceFolderRestrictedValue');
2474
	}));
2475

2476
	test('inspect restricted settings after change', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2477
		testObject.updateWorkspaceTrust(false);
2478
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.testRestrictedSetting1": "userRestrictedValue" }'));
2479
		await testObject.reloadConfiguration();
2480

2481
		let promise = Event.toPromise(testObject.onDidChangeConfiguration);
2482
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testRestrictedSetting1': 'workspaceRestrictedValue' } }], true);
2483
		let event = await promise;
2484

2485
		let actual = testObject.inspect('configurationService.workspace.testRestrictedSetting1', { resource: workspaceContextService.getWorkspace().folders[0].uri });
2486
		assert.strictEqual(actual.defaultValue, 'isSet');
2487
		assert.strictEqual(actual.application, undefined);
2488
		assert.strictEqual(actual.userValue, 'userRestrictedValue');
2489
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
2490
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2491
		assert.strictEqual(actual.value, 'userRestrictedValue');
2492
		assert.strictEqual(event.affectsConfiguration('configurationService.workspace.testRestrictedSetting1'), true);
2493

2494
		promise = Event.toPromise(testObject.onDidChangeConfiguration);
2495
		await fileService.writeFile(workspaceContextService.getWorkspace().folders[0].toResource('.vscode/settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testRestrictedSetting1": "workspaceFolderRestrictedValue" }'));
2496
		event = await promise;
2497

2498
		actual = testObject.inspect('configurationService.workspace.testRestrictedSetting1', { resource: workspaceContextService.getWorkspace().folders[0].uri });
2499
		assert.strictEqual(actual.defaultValue, 'isSet');
2500
		assert.strictEqual(actual.application, undefined);
2501
		assert.strictEqual(actual.userValue, 'userRestrictedValue');
2502
		assert.strictEqual(actual.workspaceValue, 'workspaceRestrictedValue');
2503
		assert.strictEqual(actual.workspaceFolderValue, 'workspaceFolderRestrictedValue');
2504
		assert.strictEqual(actual.value, 'userRestrictedValue');
2505
		assert.strictEqual(event.affectsConfiguration('configurationService.workspace.testRestrictedSetting1'), true);
2506
	}));
2507

2508
	test('get launch configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2509
		const expectedLaunchConfiguration = {
2510
			'version': '0.1.0',
2511
			'configurations': [
2512
				{
2513
					'type': 'node',
2514
					'request': 'launch',
2515
					'name': 'Gulp Build',
2516
					'program': '${workspaceFolder}/node_modules/gulp/bin/gulp.js',
2517
					'stopOnEntry': true,
2518
					'args': [
2519
						'watch-extension:json-client'
2520
					],
2521
					'cwd': '${workspaceFolder}'
2522
				}
2523
			]
2524
		};
2525
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['launch'], value: expectedLaunchConfiguration }], true);
2526
		await testObject.reloadConfiguration();
2527
		const actual = testObject.getValue('launch');
2528
		assert.deepStrictEqual(actual, expectedLaunchConfiguration);
2529
	}));
2530

2531
	test('inspect launch configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2532
		const expectedLaunchConfiguration = {
2533
			'version': '0.1.0',
2534
			'configurations': [
2535
				{
2536
					'type': 'node',
2537
					'request': 'launch',
2538
					'name': 'Gulp Build',
2539
					'program': '${workspaceFolder}/node_modules/gulp/bin/gulp.js',
2540
					'stopOnEntry': true,
2541
					'args': [
2542
						'watch-extension:json-client'
2543
					],
2544
					'cwd': '${workspaceFolder}'
2545
				}
2546
			]
2547
		};
2548
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['launch'], value: expectedLaunchConfiguration }], true);
2549
		await testObject.reloadConfiguration();
2550
		const actual = testObject.inspect('launch').workspaceValue;
2551
		assert.deepStrictEqual(actual, expectedLaunchConfiguration);
2552
	}));
2553

2554

2555
	test('get tasks configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2556
		const expectedTasksConfiguration = {
2557
			'version': '2.0.0',
2558
			'tasks': [
2559
				{
2560
					'label': 'Run Dev',
2561
					'type': 'shell',
2562
					'command': './scripts/code.sh',
2563
					'windows': {
2564
						'command': '.\\scripts\\code.bat'
2565
					},
2566
					'problemMatcher': []
2567
				}
2568
			]
2569
		};
2570
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['tasks'], value: expectedTasksConfiguration }], true);
2571
		await testObject.reloadConfiguration();
2572
		const actual = testObject.getValue(TasksSchemaProperties.Tasks);
2573
		assert.deepStrictEqual(actual, expectedTasksConfiguration);
2574
	}));
2575

2576
	test('inspect tasks configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2577
		const expectedTasksConfiguration = {
2578
			'version': '2.0.0',
2579
			'tasks': [
2580
				{
2581
					'label': 'Run Dev',
2582
					'type': 'shell',
2583
					'command': './scripts/code.sh',
2584
					'windows': {
2585
						'command': '.\\scripts\\code.bat'
2586
					},
2587
					'problemMatcher': []
2588
				}
2589
			]
2590
		};
2591
		await jsonEditingServce.write(workspaceContextService.getWorkspace().configuration!, [{ path: ['tasks'], value: expectedTasksConfiguration }], true);
2592
		await testObject.reloadConfiguration();
2593
		const actual = testObject.inspect('tasks').workspaceValue;
2594
		assert.deepStrictEqual(actual, expectedTasksConfiguration);
2595
	}));
2596

2597
	test('update user configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2598
		await testObject.updateValue('configurationService.workspace.testSetting', 'userValue', ConfigurationTarget.USER);
2599
		assert.strictEqual(testObject.getValue('configurationService.workspace.testSetting'), 'userValue');
2600
	}));
2601

2602
	test('update user configuration should trigger change event before promise is resolve', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2603
		const target = sinon.spy();
2604
		disposables.add(testObject.onDidChangeConfiguration(target));
2605
		await testObject.updateValue('configurationService.workspace.testSetting', 'userValue', ConfigurationTarget.USER);
2606
		assert.ok(target.called);
2607
	}));
2608

2609
	test('update workspace configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2610
		await testObject.updateValue('configurationService.workspace.testSetting', 'workspaceValue', ConfigurationTarget.WORKSPACE);
2611
		assert.strictEqual(testObject.getValue('configurationService.workspace.testSetting'), 'workspaceValue');
2612
	}));
2613

2614
	test('update workspace configuration should trigger change event before promise is resolve', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2615
		const target = sinon.spy();
2616
		disposables.add(testObject.onDidChangeConfiguration(target));
2617
		await testObject.updateValue('configurationService.workspace.testSetting', 'workspaceValue', ConfigurationTarget.WORKSPACE);
2618
		assert.ok(target.called);
2619
	}));
2620

2621
	test('update application setting into workspace configuration in a workspace is not supported', () => {
2622
		return testObject.updateValue('configurationService.workspace.applicationSetting', 'workspaceValue', {}, ConfigurationTarget.WORKSPACE, { donotNotifyError: true })
2623
			.then(() => assert.fail('Should not be supported'), (e) => assert.strictEqual(e.code, ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_APPLICATION));
2624
	});
2625

2626
	test('update machine setting into workspace configuration in a workspace is not supported', () => {
2627
		return testObject.updateValue('configurationService.workspace.machineSetting', 'workspaceValue', {}, ConfigurationTarget.WORKSPACE, { donotNotifyError: true })
2628
			.then(() => assert.fail('Should not be supported'), (e) => assert.strictEqual(e.code, ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_MACHINE));
2629
	});
2630

2631
	test('update workspace folder configuration', () => {
2632
		const workspace = workspaceContextService.getWorkspace();
2633
		return testObject.updateValue('configurationService.workspace.testResourceSetting', 'workspaceFolderValue', { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER)
2634
			.then(() => assert.strictEqual(testObject.getValue('configurationService.workspace.testResourceSetting', { resource: workspace.folders[0].uri }), 'workspaceFolderValue'));
2635
	});
2636

2637
	test('update resource language configuration in workspace folder', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2638
		const workspace = workspaceContextService.getWorkspace();
2639
		await testObject.updateValue('configurationService.workspace.testLanguageSetting', 'workspaceFolderValue', { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
2640
		assert.strictEqual(testObject.getValue('configurationService.workspace.testLanguageSetting', { resource: workspace.folders[0].uri }), 'workspaceFolderValue');
2641
	}));
2642

2643
	test('update workspace folder configuration should trigger change event before promise is resolve', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2644
		const workspace = workspaceContextService.getWorkspace();
2645
		const target = sinon.spy();
2646
		disposables.add(testObject.onDidChangeConfiguration(target));
2647
		await testObject.updateValue('configurationService.workspace.testResourceSetting', 'workspaceFolderValue', { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
2648
		assert.ok(target.called);
2649
	}));
2650

2651
	test('update workspace folder configuration second time should trigger change event before promise is resolve', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2652
		const workspace = workspaceContextService.getWorkspace();
2653
		await testObject.updateValue('configurationService.workspace.testResourceSetting', 'workspaceFolderValue', { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
2654
		const target = sinon.spy();
2655
		disposables.add(testObject.onDidChangeConfiguration(target));
2656
		await testObject.updateValue('configurationService.workspace.testResourceSetting', 'workspaceFolderValue2', { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
2657
		assert.ok(target.called);
2658
	}));
2659

2660
	test('update machine overridable setting in folder', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2661
		const workspace = workspaceContextService.getWorkspace();
2662
		await testObject.updateValue('configurationService.workspace.machineOverridableSetting', 'workspaceFolderValue', { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
2663
		assert.strictEqual(testObject.getValue('configurationService.workspace.machineOverridableSetting', { resource: workspace.folders[0].uri }), 'workspaceFolderValue');
2664
	}));
2665

2666
	test('update memory configuration', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2667
		await testObject.updateValue('configurationService.workspace.testSetting', 'memoryValue', ConfigurationTarget.MEMORY);
2668
		assert.strictEqual(testObject.getValue('configurationService.workspace.testSetting'), 'memoryValue');
2669
	}));
2670

2671
	test('update memory configuration should trigger change event before promise is resolve', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2672
		const target = sinon.spy();
2673
		disposables.add(testObject.onDidChangeConfiguration(target));
2674
		await testObject.updateValue('configurationService.workspace.testSetting', 'memoryValue', ConfigurationTarget.MEMORY);
2675
		assert.ok(target.called);
2676
	}));
2677

2678
	test('remove setting from all targets', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2679
		const workspace = workspaceContextService.getWorkspace();
2680
		const key = 'configurationService.workspace.testResourceSetting';
2681
		await testObject.updateValue(key, 'workspaceFolderValue', { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
2682
		await testObject.updateValue(key, 'workspaceValue', ConfigurationTarget.WORKSPACE);
2683
		await testObject.updateValue(key, 'userValue', ConfigurationTarget.USER);
2684

2685
		await testObject.updateValue(key, undefined, { resource: workspace.folders[0].uri });
2686
		await testObject.reloadConfiguration();
2687

2688
		const actual = testObject.inspect(key, { resource: workspace.folders[0].uri });
2689
		assert.strictEqual(actual.userValue, undefined);
2690
		assert.strictEqual(actual.workspaceValue, undefined);
2691
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2692
	}));
2693

2694
	test('update tasks configuration in a folder', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2695
		const workspace = workspaceContextService.getWorkspace();
2696
		await testObject.updateValue('tasks', { 'version': '1.0.0', tasks: [{ 'taskName': 'myTask' }] }, { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE_FOLDER);
2697
		assert.deepStrictEqual(testObject.getValue(TasksSchemaProperties.Tasks, { resource: workspace.folders[0].uri }), { 'version': '1.0.0', tasks: [{ 'taskName': 'myTask' }] });
2698
	}));
2699

2700
	test('update launch configuration in a workspace', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2701
		const workspace = workspaceContextService.getWorkspace();
2702
		await testObject.updateValue('launch', { 'version': '1.0.0', configurations: [{ 'name': 'myLaunch' }] }, { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE, { donotNotifyError: true });
2703
		assert.deepStrictEqual(testObject.getValue('launch'), { 'version': '1.0.0', configurations: [{ 'name': 'myLaunch' }] });
2704
	}));
2705

2706
	test('update tasks configuration in a workspace', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2707
		const workspace = workspaceContextService.getWorkspace();
2708
		const tasks = { 'version': '2.0.0', tasks: [{ 'label': 'myTask' }] };
2709
		await testObject.updateValue('tasks', tasks, { resource: workspace.folders[0].uri }, ConfigurationTarget.WORKSPACE, { donotNotifyError: true });
2710
		assert.deepStrictEqual(testObject.getValue(TasksSchemaProperties.Tasks), tasks);
2711
	}));
2712

2713
	test('configuration of newly added folder is available on configuration change event', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2714
		const workspaceService = <WorkspaceService>testObject;
2715
		const uri = workspaceService.getWorkspace().folders[1].uri;
2716
		await workspaceService.removeFolders([uri]);
2717
		await fileService.writeFile(joinPath(uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testResourceSetting": "workspaceFolderValue" }'));
2718

2719
		return new Promise<void>((c, e) => {
2720
			disposables.add(testObject.onDidChangeConfiguration(() => {
2721
				try {
2722
					assert.strictEqual(testObject.getValue('configurationService.workspace.testResourceSetting', { resource: uri }), 'workspaceFolderValue');
2723
					c();
2724
				} catch (error) {
2725
					e(error);
2726
				}
2727
			}));
2728
			workspaceService.addFolders([{ uri }]);
2729
		});
2730
	}));
2731

2732
	test('restricted setting is read from workspace folders when workspace is trusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2733
		testObject.updateWorkspaceTrust(true);
2734

2735
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.testRestrictedSetting1": "userValue", "configurationService.workspace.testRestrictedSetting2": "userValue" }'));
2736
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testRestrictedSetting1': 'workspaceValue' } }], true);
2737
		await fileService.writeFile(joinPath(testObject.getWorkspace().folders[1].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testRestrictedSetting2": "workspaceFolder2Value" }'));
2738
		await testObject.reloadConfiguration();
2739

2740
		assert.strictEqual(testObject.getValue('configurationService.workspace.testRestrictedSetting1', { resource: testObject.getWorkspace().folders[0].uri }), 'workspaceValue');
2741
		assert.strictEqual(testObject.getValue('configurationService.workspace.testRestrictedSetting2', { resource: testObject.getWorkspace().folders[1].uri }), 'workspaceFolder2Value');
2742
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.workspace.testRestrictedSetting1'));
2743
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.workspace.testRestrictedSetting2'));
2744
		assert.strictEqual(testObject.restrictedSettings.userLocal, undefined);
2745
		assert.strictEqual(testObject.restrictedSettings.userRemote, undefined);
2746
		assert.deepStrictEqual(testObject.restrictedSettings.workspace, ['configurationService.workspace.testRestrictedSetting1']);
2747
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.size, 1);
2748
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.get(testObject.getWorkspace().folders[0].uri), undefined);
2749
		assert.deepStrictEqual(testObject.restrictedSettings.workspaceFolder?.get(testObject.getWorkspace().folders[1].uri), ['configurationService.workspace.testRestrictedSetting2']);
2750
	}));
2751

2752
	test('restricted setting is not read from workspace when workspace is not trusted', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2753
		testObject.updateWorkspaceTrust(false);
2754

2755
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.testRestrictedSetting1": "userValue", "configurationService.workspace.testRestrictedSetting2": "userValue" }'));
2756
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.testRestrictedSetting1': 'workspaceValue' } }], true);
2757
		await fileService.writeFile(joinPath(testObject.getWorkspace().folders[1].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.workspace.testRestrictedSetting2": "workspaceFolder2Value" }'));
2758
		await testObject.reloadConfiguration();
2759

2760
		assert.strictEqual(testObject.getValue('configurationService.workspace.testRestrictedSetting1', { resource: testObject.getWorkspace().folders[0].uri }), 'userValue');
2761
		assert.strictEqual(testObject.getValue('configurationService.workspace.testRestrictedSetting2', { resource: testObject.getWorkspace().folders[1].uri }), 'userValue');
2762
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.workspace.testRestrictedSetting1'));
2763
		assert.ok(testObject.restrictedSettings.default.includes('configurationService.workspace.testRestrictedSetting2'));
2764
		assert.strictEqual(testObject.restrictedSettings.userLocal, undefined);
2765
		assert.strictEqual(testObject.restrictedSettings.userRemote, undefined);
2766
		assert.deepStrictEqual(testObject.restrictedSettings.workspace, ['configurationService.workspace.testRestrictedSetting1']);
2767
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.size, 1);
2768
		assert.strictEqual(testObject.restrictedSettings.workspaceFolder?.get(testObject.getWorkspace().folders[0].uri), undefined);
2769
		assert.deepStrictEqual(testObject.restrictedSettings.workspaceFolder?.get(testObject.getWorkspace().folders[1].uri), ['configurationService.workspace.testRestrictedSetting2']);
2770
	}));
2771

2772
	test('remove an unregistered setting', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2773
		const key = 'configurationService.workspace.unknownSetting';
2774
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.workspace.unknownSetting": "userValue" }'));
2775
		await jsonEditingServce.write((workspaceContextService.getWorkspace().configuration!), [{ path: ['settings'], value: { 'configurationService.workspace.unknownSetting': 'workspaceValue' } }], true);
2776
		await fileService.writeFile(joinPath(workspaceContextService.getWorkspace().folders[0].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.workspace.unknownSetting": "workspaceFolderValue1" }'));
2777
		await fileService.writeFile(joinPath(workspaceContextService.getWorkspace().folders[1].uri, '.vscode', 'settings.json'), VSBuffer.fromString('{ "configurationService.workspace.unknownSetting": "workspaceFolderValue2" }'));
2778

2779
		await testObject.reloadConfiguration();
2780
		await testObject.updateValue(key, undefined, { resource: workspaceContextService.getWorkspace().folders[0].uri });
2781

2782
		let actual = testObject.inspect(key, { resource: workspaceContextService.getWorkspace().folders[0].uri });
2783
		assert.strictEqual(actual.userValue, undefined);
2784
		assert.strictEqual(actual.workspaceValue, undefined);
2785
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2786

2787
		await testObject.updateValue(key, undefined, { resource: workspaceContextService.getWorkspace().folders[1].uri });
2788
		actual = testObject.inspect(key, { resource: workspaceContextService.getWorkspace().folders[1].uri });
2789
		assert.strictEqual(actual.userValue, undefined);
2790
		assert.strictEqual(actual.workspaceValue, undefined);
2791
		assert.strictEqual(actual.workspaceFolderValue, undefined);
2792
	}));
2793

2794
});
2795

2796
suite('WorkspaceConfigurationService - Remote Folder', () => {
2797

2798
	let testObject: WorkspaceService, folder: URI,
2799
		machineSettingsResource: URI, remoteSettingsResource: URI, fileSystemProvider: InMemoryFileSystemProvider, resolveRemoteEnvironment: () => void,
2800
		instantiationService: TestInstantiationService, fileService: IFileService, environmentService: BrowserWorkbenchEnvironmentService, userDataProfileService: IUserDataProfileService;
2801
	const remoteAuthority = 'configuraiton-tests';
2802
	const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
2803
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
2804

2805
	suiteSetup(() => {
2806
		configurationRegistry.registerConfiguration({
2807
			'id': '_test',
2808
			'type': 'object',
2809
			'properties': {
2810
				'configurationService.remote.applicationSetting': {
2811
					'type': 'string',
2812
					'default': 'isSet',
2813
					scope: ConfigurationScope.APPLICATION
2814
				},
2815
				'configurationService.remote.machineSetting': {
2816
					'type': 'string',
2817
					'default': 'isSet',
2818
					scope: ConfigurationScope.MACHINE
2819
				},
2820
				'configurationService.remote.applicationMachineSetting': {
2821
					'type': 'string',
2822
					'default': 'isSet',
2823
					scope: ConfigurationScope.APPLICATION_MACHINE
2824
				},
2825
				'configurationService.remote.machineOverridableSetting': {
2826
					'type': 'string',
2827
					'default': 'isSet',
2828
					scope: ConfigurationScope.MACHINE_OVERRIDABLE
2829
				},
2830
				'configurationService.remote.testSetting': {
2831
					'type': 'string',
2832
					'default': 'isSet',
2833
					scope: ConfigurationScope.RESOURCE
2834
				}
2835
			}
2836
		});
2837
	});
2838

2839
	setup(async () => {
2840
		const logService = new NullLogService();
2841
		fileService = disposables.add(new FileService(logService));
2842
		fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
2843
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
2844

2845
		const appSettingsHome = joinPath(ROOT, 'user');
2846
		folder = joinPath(ROOT, 'a');
2847
		await fileService.createFolder(folder);
2848
		await fileService.createFolder(appSettingsHome);
2849
		machineSettingsResource = joinPath(ROOT, 'machine-settings.json');
2850
		remoteSettingsResource = machineSettingsResource.with({ scheme: Schemas.vscodeRemote, authority: remoteAuthority });
2851

2852
		instantiationService = workbenchInstantiationService(undefined, disposables);
2853
		environmentService = TestEnvironmentService;
2854
		const remoteEnvironmentPromise = new Promise<Partial<IRemoteAgentEnvironment>>(c => resolveRemoteEnvironment = () => c({ settingsPath: remoteSettingsResource }));
2855
		const remoteAgentService = instantiationService.stub(IRemoteAgentService, <Partial<IRemoteAgentService>>{ getEnvironment: () => remoteEnvironmentPromise });
2856
		const configurationCache: IConfigurationCache = { read: () => Promise.resolve(''), write: () => Promise.resolve(), remove: () => Promise.resolve(), needsCaching: () => false };
2857
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
2858
		const userDataProfilesService = instantiationService.stub(IUserDataProfilesService, disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService)));
2859
		disposables.add(fileService.registerProvider(Schemas.vscodeUserData, disposables.add(new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, userDataProfilesService, uriIdentityService, new NullLogService()))));
2860
		userDataProfileService = instantiationService.stub(IUserDataProfileService, disposables.add(new UserDataProfileService(userDataProfilesService.defaultProfile)));
2861
		testObject = disposables.add(new WorkspaceService({ configurationCache, remoteAuthority }, environmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, new NullLogService(), new NullPolicyService()));
2862
		instantiationService.stub(IWorkspaceContextService, testObject);
2863
		instantiationService.stub(IConfigurationService, testObject);
2864
		instantiationService.stub(IEnvironmentService, environmentService);
2865
		instantiationService.stub(IFileService, fileService);
2866
	});
2867

2868
	async function initialize(): Promise<void> {
2869
		await testObject.initialize(convertToWorkspacePayload(folder));
2870
		instantiationService.stub(ITextFileService, disposables.add(instantiationService.createInstance(TestTextFileService)));
2871
		instantiationService.stub(ITextModelService, <ITextModelService>disposables.add(instantiationService.createInstance(TextModelResolverService)));
2872
		instantiationService.stub(IJSONEditingService, instantiationService.createInstance(JSONEditingService));
2873
		testObject.acquireInstantiationService(instantiationService);
2874
	}
2875

2876
	function registerRemoteFileSystemProvider(): void {
2877
		disposables.add(instantiationService.get(IFileService).registerProvider(Schemas.vscodeRemote, new RemoteFileSystemProvider(fileSystemProvider, remoteAuthority)));
2878
	}
2879

2880
	function registerRemoteFileSystemProviderOnActivation(): void {
2881
		const disposable = disposables.add(instantiationService.get(IFileService).onWillActivateFileSystemProvider(e => {
2882
			if (e.scheme === Schemas.vscodeRemote) {
2883
				disposable.dispose();
2884
				e.join(Promise.resolve().then(() => registerRemoteFileSystemProvider()));
2885
			}
2886
		}));
2887
	}
2888

2889
	test('remote machine settings override globals', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2890
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.machineSetting": "remoteValue" }'));
2891
		registerRemoteFileSystemProvider();
2892
		resolveRemoteEnvironment();
2893
		await initialize();
2894
		assert.strictEqual(testObject.getValue('configurationService.remote.machineSetting'), 'remoteValue');
2895
	}));
2896

2897
	test('remote machine settings override globals after remote provider is registered on activation', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2898
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.machineSetting": "remoteValue" }'));
2899
		resolveRemoteEnvironment();
2900
		registerRemoteFileSystemProviderOnActivation();
2901
		await initialize();
2902
		assert.strictEqual(testObject.getValue('configurationService.remote.machineSetting'), 'remoteValue');
2903
	}));
2904

2905
	test('remote machine settings override globals after remote environment is resolved', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2906
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.machineSetting": "remoteValue" }'));
2907
		registerRemoteFileSystemProvider();
2908
		await initialize();
2909
		const promise = new Promise<void>((c, e) => {
2910
			disposables.add(testObject.onDidChangeConfiguration(event => {
2911
				try {
2912
					assert.strictEqual(event.source, ConfigurationTarget.USER);
2913
					assert.deepStrictEqual([...event.affectedKeys], ['configurationService.remote.machineSetting']);
2914
					assert.strictEqual(testObject.getValue('configurationService.remote.machineSetting'), 'remoteValue');
2915
					c();
2916
				} catch (error) {
2917
					e(error);
2918
				}
2919
			}));
2920
		});
2921
		resolveRemoteEnvironment();
2922
		return promise;
2923
	}));
2924

2925
	test('remote settings override globals after remote provider is registered on activation and remote environment is resolved', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2926
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.machineSetting": "remoteValue" }'));
2927
		registerRemoteFileSystemProviderOnActivation();
2928
		await initialize();
2929
		const promise = new Promise<void>((c, e) => {
2930
			disposables.add(testObject.onDidChangeConfiguration(event => {
2931
				try {
2932
					assert.strictEqual(event.source, ConfigurationTarget.USER);
2933
					assert.deepStrictEqual([...event.affectedKeys], ['configurationService.remote.machineSetting']);
2934
					assert.strictEqual(testObject.getValue('configurationService.remote.machineSetting'), 'remoteValue');
2935
					c();
2936
				} catch (error) {
2937
					e(error);
2938
				}
2939
			}));
2940
		});
2941
		resolveRemoteEnvironment();
2942
		return promise;
2943
	}));
2944

2945
	test('machine settings in local user settings does not override defaults', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2946
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.remote.machineSetting": "globalValue" }'));
2947
		registerRemoteFileSystemProvider();
2948
		resolveRemoteEnvironment();
2949
		await initialize();
2950
		assert.strictEqual(testObject.getValue('configurationService.remote.machineSetting'), 'isSet');
2951
	}));
2952

2953
	test('remote application machine settings override globals', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2954
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.applicationMachineSetting": "remoteValue" }'));
2955
		registerRemoteFileSystemProvider();
2956
		resolveRemoteEnvironment();
2957
		await initialize();
2958
		assert.strictEqual(testObject.getValue('configurationService.remote.applicationMachineSetting'), 'remoteValue');
2959
	}));
2960

2961
	test('remote application machine settings override globals after remote provider is registered on activation', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2962
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.applicationMachineSetting": "remoteValue" }'));
2963
		resolveRemoteEnvironment();
2964
		registerRemoteFileSystemProviderOnActivation();
2965
		await initialize();
2966
		assert.strictEqual(testObject.getValue('configurationService.remote.applicationMachineSetting'), 'remoteValue');
2967
	}));
2968

2969
	test('remote application machine settings override globals after remote environment is resolved', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2970
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.applicationMachineSetting": "remoteValue" }'));
2971
		registerRemoteFileSystemProvider();
2972
		await initialize();
2973
		const promise = new Promise<void>((c, e) => {
2974
			disposables.add(testObject.onDidChangeConfiguration(event => {
2975
				try {
2976
					assert.strictEqual(event.source, ConfigurationTarget.USER);
2977
					assert.deepStrictEqual([...event.affectedKeys], ['configurationService.remote.applicationMachineSetting']);
2978
					assert.strictEqual(testObject.getValue('configurationService.remote.applicationMachineSetting'), 'remoteValue');
2979
					c();
2980
				} catch (error) {
2981
					e(error);
2982
				}
2983
			}));
2984
		});
2985
		resolveRemoteEnvironment();
2986
		return promise;
2987
	}));
2988

2989
	test('remote application machine settings override globals after remote provider is registered on activation and remote environment is resolved', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
2990
		await fileService.writeFile(machineSettingsResource, VSBuffer.fromString('{ "configurationService.remote.applicationMachineSetting": "remoteValue" }'));
2991
		registerRemoteFileSystemProviderOnActivation();
2992
		await initialize();
2993
		const promise = new Promise<void>((c, e) => {
2994
			disposables.add(testObject.onDidChangeConfiguration(event => {
2995
				try {
2996
					assert.strictEqual(event.source, ConfigurationTarget.USER);
2997
					assert.deepStrictEqual([...event.affectedKeys], ['configurationService.remote.applicationMachineSetting']);
2998
					assert.strictEqual(testObject.getValue('configurationService.remote.applicationMachineSetting'), 'remoteValue');
2999
					c();
3000
				} catch (error) {
3001
					e(error);
3002
				}
3003
			}));
3004
		});
3005
		resolveRemoteEnvironment();
3006
		return promise;
3007
	}));
3008

3009
	test('application machine settings in local user settings does not override defaults', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3010
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.remote.applicationMachineSetting": "globalValue" }'));
3011
		registerRemoteFileSystemProvider();
3012
		resolveRemoteEnvironment();
3013
		await initialize();
3014
		assert.strictEqual(testObject.getValue('configurationService.remote.applicationMachineSetting'), 'isSet');
3015
	}));
3016

3017
	test('machine overridable settings in local user settings does not override defaults', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3018
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.remote.machineOverridableSetting": "globalValue" }'));
3019
		registerRemoteFileSystemProvider();
3020
		resolveRemoteEnvironment();
3021
		await initialize();
3022
		assert.strictEqual(testObject.getValue('configurationService.remote.machineOverridableSetting'), 'isSet');
3023
	}));
3024

3025
	test('non machine setting is written in local settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3026
		registerRemoteFileSystemProvider();
3027
		resolveRemoteEnvironment();
3028
		await initialize();
3029
		await testObject.updateValue('configurationService.remote.applicationSetting', 'applicationValue');
3030
		await testObject.reloadConfiguration();
3031
		assert.strictEqual(testObject.inspect('configurationService.remote.applicationSetting').userLocalValue, 'applicationValue');
3032
	}));
3033

3034
	test('machine setting is written in remote settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3035
		registerRemoteFileSystemProvider();
3036
		resolveRemoteEnvironment();
3037
		await initialize();
3038
		await testObject.updateValue('configurationService.remote.machineSetting', 'machineValue');
3039
		await testObject.reloadConfiguration();
3040
		assert.strictEqual(testObject.inspect('configurationService.remote.machineSetting').userRemoteValue, 'machineValue');
3041
	}));
3042

3043
	test('application machine setting is written in remote settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3044
		registerRemoteFileSystemProvider();
3045
		resolveRemoteEnvironment();
3046
		await initialize();
3047
		await testObject.updateValue('configurationService.remote.applicationMachineSetting', 'machineValue');
3048
		await testObject.reloadConfiguration();
3049
		const actual = testObject.inspect('configurationService.remote.applicationMachineSetting');
3050
		assert.strictEqual(actual.userRemoteValue, 'machineValue');
3051
	}));
3052

3053
	test('machine overridable setting is written in remote settings', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3054
		registerRemoteFileSystemProvider();
3055
		resolveRemoteEnvironment();
3056
		await initialize();
3057
		await testObject.updateValue('configurationService.remote.machineOverridableSetting', 'machineValue');
3058
		await testObject.reloadConfiguration();
3059
		assert.strictEqual(testObject.inspect('configurationService.remote.machineOverridableSetting').userRemoteValue, 'machineValue');
3060
	}));
3061

3062
	test('machine settings in local user settings does not override defaults after defalts are registered ', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3063
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.remote.newMachineSetting": "userValue" }'));
3064
		registerRemoteFileSystemProvider();
3065
		resolveRemoteEnvironment();
3066
		await initialize();
3067
		configurationRegistry.registerConfiguration({
3068
			'id': '_test',
3069
			'type': 'object',
3070
			'properties': {
3071
				'configurationService.remote.newMachineSetting': {
3072
					'type': 'string',
3073
					'default': 'isSet',
3074
					scope: ConfigurationScope.MACHINE
3075
				}
3076
			}
3077
		});
3078
		assert.strictEqual(testObject.getValue('configurationService.remote.newMachineSetting'), 'isSet');
3079
	}));
3080

3081
	test('machine overridable settings in local user settings does not override defaults after defaults are registered ', () => runWithFakedTimers<void>({ useFakeTimers: true }, async () => {
3082
		await fileService.writeFile(userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString('{ "configurationService.remote.newMachineOverridableSetting": "userValue" }'));
3083
		registerRemoteFileSystemProvider();
3084
		resolveRemoteEnvironment();
3085
		await initialize();
3086
		configurationRegistry.registerConfiguration({
3087
			'id': '_test',
3088
			'type': 'object',
3089
			'properties': {
3090
				'configurationService.remote.newMachineOverridableSetting': {
3091
					'type': 'string',
3092
					'default': 'isSet',
3093
					scope: ConfigurationScope.MACHINE_OVERRIDABLE
3094
				}
3095
			}
3096
		});
3097
		assert.strictEqual(testObject.getValue('configurationService.remote.newMachineOverridableSetting'), 'isSet');
3098
	}));
3099

3100
});
3101

3102
function getWorkspaceId(configPath: URI): string {
3103
	let workspaceConfigPath = configPath.toString();
3104
	if (!isLinux) {
3105
		workspaceConfigPath = workspaceConfigPath.toLowerCase(); // sanitize for platform file system
3106
	}
3107
	return hash(workspaceConfigPath).toString(16);
3108
}
3109

3110
function getWorkspaceIdentifier(configPath: URI): IWorkspaceIdentifier {
3111
	return {
3112
		configPath,
3113
		id: getWorkspaceId(configPath)
3114
	};
3115
}
3116

3117
Product

Resources

Company
