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

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

25
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
26

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

93
	suiteSetup(() => Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration(policyConfigurationNode));
94
	suiteTeardown(() => Registry.as<IConfigurationRegistry>(Extensions.Configuration).deregisterConfigurations([policyConfigurationNode]));
95

96
	setup(async () => {
97
		const defaultConfiguration = disposables.add(new DefaultConfiguration(new NullLogService()));
98
		await defaultConfiguration.initialize();
99
		fileService = disposables.add(new FileService(new NullLogService()));
100
		const diskFileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
101
		disposables.add(fileService.registerProvider(policyFile.scheme, diskFileSystemProvider));
102
		policyService = disposables.add(new FilePolicyService(policyFile, fileService, new NullLogService()));
103
		testObject = disposables.add(new PolicyConfiguration(defaultConfiguration, policyService, new NullLogService()));
104
	});
105

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

109
		await testObject.initialize();
110
		const acutal = testObject.configurationModel;
111

112
		assert.strictEqual(acutal.getValue('policy.settingA'), 'policyValueA');
113
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
114
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
115
		assert.deepStrictEqual(acutal.keys, ['policy.settingA']);
116
		assert.deepStrictEqual(acutal.overrides, []);
117
	});
118

119
	test('initialize: no policies', async () => {
120
		await testObject.initialize();
121
		const acutal = testObject.configurationModel;
122

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

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

133
		await testObject.initialize();
134
		const acutal = testObject.configurationModel;
135

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

143
	test('initialize: with object type policy', async () => {
144
		const expected = {
145
			'microsoft': true,
146
			'github': 'stable',
147
			'other': 1,
148
			'complex': {
149
				'key': 'value'
150
			},
151
			'array': [1, 2, 3]
152
		};
153
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicyObjectSetting': JSON.stringify(expected) })));
154

155
		await testObject.initialize();
156
		const acutal = testObject.configurationModel;
157

158
		assert.deepStrictEqual(acutal.getValue('policy.objectSetting'), expected);
159
	});
160

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

164
		await testObject.initialize();
165
		const acutal = testObject.configurationModel;
166

167
		assert.deepStrictEqual(acutal.getValue('policy.arraySetting'), [1]);
168
	});
169

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

173
		await testObject.initialize();
174
		const acutal = testObject.configurationModel;
175

176
		assert.deepStrictEqual(acutal.getValue('policy.booleanSetting'), false);
177
	});
178

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

182
		await testObject.initialize();
183
		const acutal = testObject.configurationModel;
184

185
		assert.deepStrictEqual(acutal.getValue('policy.booleanSetting'), true);
186
	});
187

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

191
		await testObject.initialize();
192
		const acutal = testObject.configurationModel;
193

194
		assert.deepStrictEqual(acutal.getValue('policy.objectSetting'), undefined);
195
	});
196

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

200
		await testObject.initialize();
201
		const acutal = testObject.configurationModel;
202

203
		assert.deepStrictEqual(acutal.getValue('policy.objectSetting'), undefined);
204
	});
205

206
	test('change: when policy is added', async () => {
207
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
208
		await testObject.initialize();
209

210
		await runWithFakedTimers({ useFakeTimers: true }, async () => {
211
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
212
			await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA', 'PolicySettingB': 'policyValueB', 'PolicySettingC': 'policyValueC' })));
213
			await promise;
214
		});
215

216
		const acutal = testObject.configurationModel;
217
		assert.strictEqual(acutal.getValue('policy.settingA'), 'policyValueA');
218
		assert.strictEqual(acutal.getValue('policy.settingB'), 'policyValueB');
219
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
220
		assert.deepStrictEqual(acutal.keys, ['policy.settingA', 'policy.settingB']);
221
		assert.deepStrictEqual(acutal.overrides, []);
222
	});
223

224
	test('change: when policy is updated', async () => {
225
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
226
		await testObject.initialize();
227

228
		await runWithFakedTimers({ useFakeTimers: true }, async () => {
229
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
230
			await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueAChanged' })));
231
			await promise;
232
		});
233

234
		const acutal = testObject.configurationModel;
235
		assert.strictEqual(acutal.getValue('policy.settingA'), 'policyValueAChanged');
236
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
237
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
238
		assert.deepStrictEqual(acutal.keys, ['policy.settingA']);
239
		assert.deepStrictEqual(acutal.overrides, []);
240
	});
241

242
	test('change: when policy is removed', async () => {
243
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
244
		await testObject.initialize();
245

246
		await runWithFakedTimers({ useFakeTimers: true }, async () => {
247
			const promise = Event.toPromise(testObject.onDidChangeConfiguration);
248
			await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({})));
249
			await promise;
250
		});
251

252
		const acutal = testObject.configurationModel;
253
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
254
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
255
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
256
		assert.deepStrictEqual(acutal.keys, []);
257
		assert.deepStrictEqual(acutal.overrides, []);
258
	});
259

260
	test('change: when policy setting is registered', async () => {
261
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingC': 'policyValueC' })));
262
		await testObject.initialize();
263

264
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
265
		policyConfigurationNode.properties!['policy.settingC'] = {
266
			'type': 'string',
267
			'default': 'defaultValueC',
268
			policy: {
269
				name: 'PolicySettingC',
270
				minimumVersion: '1.0.0',
271
			}
272
		};
273
		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration(deepClone(policyConfigurationNode));
274
		await promise;
275

276
		const acutal = testObject.configurationModel;
277
		assert.strictEqual(acutal.getValue('policy.settingC'), 'policyValueC');
278
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
279
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
280
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
281
		assert.deepStrictEqual(acutal.keys, ['policy.settingC']);
282
		assert.deepStrictEqual(acutal.overrides, []);
283
	});
284

285
	test('change: when policy setting is deregistered', async () => {
286
		await fileService.writeFile(policyFile, VSBuffer.fromString(JSON.stringify({ 'PolicySettingA': 'policyValueA' })));
287
		await testObject.initialize();
288

289
		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
290
		Registry.as<IConfigurationRegistry>(Extensions.Configuration).deregisterConfigurations([policyConfigurationNode]);
291
		await promise;
292

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

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

304
		await testObject.initialize();
305
		const acutal = testObject.configurationModel;
306

307
		assert.strictEqual(acutal.getValue('policy.settingA'), undefined);
308
		assert.strictEqual(acutal.getValue('policy.settingB'), undefined);
309
		assert.strictEqual(acutal.getValue('policy.internalSetting'), 'internalValue');
310
		assert.strictEqual(acutal.getValue('nonPolicy.setting'), undefined);
311
		assert.deepStrictEqual(acutal.keys, ['policy.internalSetting']);
312
		assert.deepStrictEqual(acutal.overrides, []);
313
	});
314

315
});
316

317
Product

Resources

Company
