CoCalc -- policyConfiguration.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/platform/configuration/test/common/policyConfiguration.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 { Event } from '../../../../base/common/event.js';
8
import { URI } from '../../../../base/common/uri.js';
9
import { DefaultConfiguration, PolicyConfiguration } from '../../common/configurations.js';
10
import { IFileService } from '../../../files/common/files.js';
11
import { FileService } from '../../../files/common/fileService.js';
12
import { InMemoryFileSystemProvider } from '../../../files/common/inMemoryFilesystemProvider.js';
13
import { NullLogService } from '../../../log/common/log.js';
14
import { Extensions, IConfigurationNode, IConfigurationRegistry } from '../../common/configurationRegistry.js';
15
import { Registry } from '../../../registry/common/platform.js';
16
import { VSBuffer } from '../../../../base/common/buffer.js';
17
import { deepClone } from '../../../../base/common/objects.js';
18
import { IPolicyService } from '../../../policy/common/policy.js';
19
import { FilePolicyService } from '../../../policy/common/filePolicyService.js';
20
import { runWithFakedTimers } from '../../../../base/test/common/timeTravelScheduler.js';
21
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
22
import { PolicyCategory } from '../../../../base/common/policy.js';
23

24
suite('PolicyConfiguration', () => {
25

26
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
27

28
	let testObject: PolicyConfiguration;
29
	let fileService: IFileService;
30
	let policyService: IPolicyService;
31
	const policyFile = URI.file('policyFile').with({ scheme: 'vscode-tests' });
32
	const policyConfigurationNode: IConfigurationNode = {
33
		'id': 'policyConfiguration',
34
		'order': 1,
35
		'title': 'a',
36
		'type': 'object',
37
		'properties': {
38
			'policy.settingA': {
39
				'type': 'string',
40
				'default': 'defaultValueA',
41
				policy: {
42
					name: 'PolicySettingA',
43
					category: PolicyCategory.Extensions,
44
					minimumVersion: '1.0.0',
45
					localization: { description: { key: '', value: '' }, }
46
				}
47
			},
48
			'policy.settingB': {
49
				'type': 'string',
50
				'default': 'defaultValueB',
51
				policy: {
52
					name: 'PolicySettingB',
53
					category: PolicyCategory.Extensions,
54
					minimumVersion: '1.0.0',
55
					localization: { description: { key: '', value: '' }, }
56
				}
57
			},
58
			'policy.objectSetting': {
59
				'type': 'object',
60
				'default': {},
61
				policy: {
62
					name: 'PolicyObjectSetting',
63
					category: PolicyCategory.Extensions,
64
					minimumVersion: '1.0.0',
65
					localization: { description: { key: '', value: '' }, }
66
				}
67
			},
68
			'policy.arraySetting': {
69
				'type': 'object',
70
				'default': [],
71
				policy: {
72
					name: 'PolicyArraySetting',
73
					category: PolicyCategory.Extensions,
74
					minimumVersion: '1.0.0',
75
					localization: { description: { key: '', value: '' }, }
76
				}
77
			},
78
			'policy.booleanSetting': {
79
				'type': 'boolean',
80
				'default': true,
81
				policy: {
82
					name: 'PolicyBooleanSetting',
83
					category: PolicyCategory.Extensions,
84
					minimumVersion: '1.0.0',
85
					localization: { description: { key: '', value: '' }, }
86
				}
87
			},
88
			'policy.internalSetting': {
89
				'type': 'string',
90
				'default': 'defaultInternalValue',
91
				included: false,
92
				policy: {
93
					name: 'PolicyInternalSetting',
94
					category: PolicyCategory.Extensions,
95
					minimumVersion: '1.0.0',
96
					localization: { description: { key: '', value: '' }, }
97
				}
98
			},
99
			'nonPolicy.setting': {
100
				'type': 'boolean',
101
				'default': true
102
			}
103
		}
104
	};
105

106
	suiteSetup(() => Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration(policyConfigurationNode));
107
	suiteTeardown(() => Registry.as<IConfigurationRegistry>(Extensions.Configuration).deregisterConfigurations([policyConfigurationNode]));
108

109
	setup(async () => {
110
		const defaultConfiguration = disposables.add(new DefaultConfiguration(new NullLogService()));
111
		await defaultConfiguration.initialize();
112
		fileService = disposables.add(new FileService(new NullLogService()));
113
		const diskFileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
114
		disposables.add(fileService.registerProvider(policyFile.scheme, diskFileSystemProvider));
115
		policyService = disposables.add(new FilePolicyService(policyFile, fileService, new NullLogService()));
116
		testObject = disposables.add(new PolicyConfiguration(defaultConfiguration, policyService, new NullLogService()));
117
	});
118

119
	test('initialize: with policies', async () => {
120
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
121

122
		await testObject.initialize();
123
		const acutal = testObject.configurationModel;
124

125
		assert.strictEqual(acutal.getValue('policy.settingA'), 'policyValueA');
126
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
127
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
128
		assert.deepStrictEqual(acutal.keys, ['policy.settingA']);
129
		assert.deepStrictEqual(acutal.overrides, []);
130
	});
131

132
	test('initialize: no policies', async () => {
133
		await testObject.initialize();
134
		const acutal = testObject.configurationModel;
135

136
		assert.deepStrictEqual(acutal.keys, []);
137
		assert.deepStrictEqual(acutal.overrides, []);
138
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
139
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
140
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
141
	});
142

143
	test('initialize: with policies but not registered', async () => {
144
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA', 'PolicySettingB': 'policyValueB', 'PolicySettingC': 'policyValueC' })));
145

146
		await testObject.initialize();
147
		const acutal = testObject.configurationModel;
148

149
		assert.strictEqual(acutal.getValue('policy.settingA'), 'policyValueA');
150
		assert.strictEqual(acutal.getValue('policy.settingB'), 'policyValueB');
151
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
152
		assert.deepStrictEqual(acutal.keys, ['policy.settingA', 'policy.settingB']);
153
		assert.deepStrictEqual(acutal.overrides, []);
154
	});
155

156
	test('initialize: with object type policy', async () => {
157
		const expected = {
158
			'microsoft': true,
159
			'github': 'stable',
160
			'other': 1,
161
			'complex': {
162
				'key': 'value'
163
			},
164
			'array': [1, 2, 3]
165
		};
166
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyObjectSetting': JSON.stringify(expected) })));
167

168
		await testObject.initialize();
169
		const acutal = testObject.configurationModel;
170

171
		assert.deepStrictEqual(acutal.getValue('policy.objectSetting'), expected);
172
	});
173

174
	test('initialize: with array type policy', async () => {
175
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyArraySetting': JSON.stringify([1]) })));
176

177
		await testObject.initialize();
178
		const acutal = testObject.configurationModel;
179

180
		assert.deepStrictEqual(acutal.getValue('policy.arraySetting'), [1]);
181
	});
182

183
	test('initialize: with boolean type policy as false', async () => {
184
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyBooleanSetting': false })));
185

186
		await testObject.initialize();
187
		const acutal = testObject.configurationModel;
188

189
		assert.deepStrictEqual(acutal.getValue('policy.booleanSetting'), false);
190
	});
191

192
	test('initialize: with boolean type policy as true', async () => {
193
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyBooleanSetting': true })));
194

195
		await testObject.initialize();
196
		const acutal = testObject.configurationModel;
197

198
		assert.deepStrictEqual(acutal.getValue('policy.booleanSetting'), true);
199
	});
200

201
	test('initialize: with object type policy ignores policy if value is not valid', async () => {
202
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyObjectSetting': '{"a": "b", "hello": }' })));
203

204
		await testObject.initialize();
205
		const acutal = testObject.configurationModel;
206

207
		assert.deepStrictEqual(acutal.getValue('policy.objectSetting'), undefined);
208
	});
209

210
	test('initialize: with object type policy ignores policy if there are duplicate keys', async () => {
211
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyObjectSetting': '{"microsoft": true, "microsoft": false }' })));
212

213
		await testObject.initialize();
214
		const acutal = testObject.configurationModel;
215

216
		assert.deepStrictEqual(acutal.getValue('policy.objectSetting'), undefined);
217
	});
218

219
	test('change: when policy is added', async () => {
220
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
221
		await testObject.initialize();
222

223
		await runWithFakedTimers({ useFakeTimers: true }, async () => {
224
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
225
			await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA', 'PolicySettingB': 'policyValueB', 'PolicySettingC': 'policyValueC' })));
226
			await promise;
227
		});
228

229
		const acutal = testObject.configurationModel;
230
		assert.strictEqual(acutal.getValue('policy.settingA'), 'policyValueA');
231
		assert.strictEqual(acutal.getValue('policy.settingB'), 'policyValueB');
232
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
233
		assert.deepStrictEqual(acutal.keys, ['policy.settingA', 'policy.settingB']);
234
		assert.deepStrictEqual(acutal.overrides, []);
235
	});
236

237
	test('change: when policy is updated', async () => {
238
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
239
		await testObject.initialize();
240

241
		await runWithFakedTimers({ useFakeTimers: true }, async () => {
242
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
243
			await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueAChanged' })));
244
			await promise;
245
		});
246

247
		const acutal = testObject.configurationModel;
248
		assert.strictEqual(acutal.getValue('policy.settingA'), 'policyValueAChanged');
249
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
250
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
251
		assert.deepStrictEqual(acutal.keys, ['policy.settingA']);
252
		assert.deepStrictEqual(acutal.overrides, []);
253
	});
254

255
	test('change: when policy is removed', async () => {
256
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
257
		await testObject.initialize();
258

259
		await runWithFakedTimers({ useFakeTimers: true }, async () => {
260
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
261
			await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({})));
262
			await promise;
263
		});
264

265
		const acutal = testObject.configurationModel;
266
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
267
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
268
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
269
		assert.deepStrictEqual(acutal.keys, []);
270
		assert.deepStrictEqual(acutal.overrides, []);
271
	});
272

273
	test('change: when policy setting is registered', async () => {
274
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingC': 'policyValueC' })));
275
		await testObject.initialize();
276

277
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
278
		policyConfigurationNode.properties!['policy.settingC'] = {
279
			'type': 'string',
280
			'default': 'defaultValueC',
281
			policy: {
282
				name: 'PolicySettingC',
283
				category: PolicyCategory.Extensions,
284
				minimumVersion: '1.0.0',
285
				localization: { description: { key: '', value: '' }, },
286
			}
287
		};
288
		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration(deepClone(policyConfigurationNode));
289
		await promise;
290

291
		const acutal = testObject.configurationModel;
292
		assert.strictEqual(acutal.getValue('policy.settingC'), 'policyValueC');
293
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
294
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
295
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
296
		assert.deepStrictEqual(acutal.keys, ['policy.settingC']);
297
		assert.deepStrictEqual(acutal.overrides, []);
298
	});
299

300
	test('change: when policy setting is deregistered', async () => {
301
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
302
		await testObject.initialize();
303

304
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
305
		Registry.as<IConfigurationRegistry>(Extensions.Configuration).deregisterConfigurations([policyConfigurationNode]);
306
		await promise;
307

308
		const acutal = testObject.configurationModel;
309
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
310
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
311
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
312
		assert.deepStrictEqual(acutal.keys, []);
313
		assert.deepStrictEqual(acutal.overrides, []);
314
	});
315

316
	test('initialize: with internal policies', async () => {
317
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyInternalSetting': 'internalValue' })));
318

319
		await testObject.initialize();
320
		const acutal = testObject.configurationModel;
321

322
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
323
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
324
		assert.strictEqual(acutal.getValue('policy.internalSetting'), 'internalValue');
325
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
326
		assert.deepStrictEqual(acutal.keys, ['policy.internalSetting']);
327
		assert.deepStrictEqual(acutal.overrides, []);
328
	});
329

330
});
331

332
Product

Resources

Company
