CoCalc -- textResourceConfigurationService.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/editor/test/common/services/textResourceConfigurationService.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 { TestConfigurationService } from '../../../../platform/configuration/test/common/testConfigurationService.js';
8
import { TestInstantiationService } from '../../../../platform/instantiation/test/common/instantiationServiceMock.js';
9
import { IModelService } from '../../../common/services/model.js';
10
import { ILanguageService } from '../../../common/languages/language.js';
11
import { IConfigurationValue, IConfigurationService, ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
12
import { TextResourceConfigurationService } from '../../../common/services/textResourceConfigurationService.js';
13
import { URI } from '../../../../base/common/uri.js';
14
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
15

16

17
suite('TextResourceConfigurationService - Update', () => {
18

19
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
20

21
	let instantiationService: TestInstantiationService;
22
	let configurationValue: IConfigurationValue<any> = {};
23
	let updateArgs: any[];
24
	const configurationService = new class extends TestConfigurationService {
25
		override inspect() {
26
			return configurationValue;
27
		}
28
		override updateValue() {
29
			updateArgs = [...arguments];
30
			return Promise.resolve();
31
		}
32
	}();
33
	let language: string | null = null;
34
	let testObject: TextResourceConfigurationService;
35

36
	setup(() => {
37
		instantiationService = disposables.add(new TestInstantiationService());
38
		instantiationService.stub(IModelService, { getModel() { return null; } });
39
		instantiationService.stub(ILanguageService, { guessLanguageIdByFilepathOrFirstLine() { return language; } });
40
		instantiationService.stub(IConfigurationService, configurationService);
41
		testObject = disposables.add(instantiationService.createInstance(TextResourceConfigurationService));
42
	});
43

44
	test('updateValue writes without target and overrides when no language is defined', async () => {
45
		const resource = URI.file('someFile');
46
		await testObject.updateValue(resource, 'a', 'b');
47
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.USER_LOCAL]);
48
	});
49

50
	test('updateValue writes with target and without overrides when no language is defined', async () => {
51
		const resource = URI.file('someFile');
52
		await testObject.updateValue(resource, 'a', 'b', ConfigurationTarget.USER_LOCAL);
53
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.USER_LOCAL]);
54
	});
55

56
	test('updateValue writes into given memory target without overrides', async () => {
57
		language = 'a';
58
		configurationValue = {
59
			default: { value: '1' },
60
			userLocal: { value: '2' },
61
			workspaceFolder: { value: '1' },
62
		};
63
		const resource = URI.file('someFile');
64

65
		await testObject.updateValue(resource, 'a', 'b', ConfigurationTarget.MEMORY);
66
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.MEMORY]);
67
	});
68

69
	test('updateValue writes into given workspace target without overrides', async () => {
70
		language = 'a';
71
		configurationValue = {
72
			default: { value: '1' },
73
			userLocal: { value: '2' },
74
			workspaceFolder: { value: '2' },
75
		};
76
		const resource = URI.file('someFile');
77

78
		await testObject.updateValue(resource, 'a', 'b', ConfigurationTarget.WORKSPACE);
79
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.WORKSPACE]);
80
	});
81

82
	test('updateValue writes into given user target without overrides', async () => {
83
		language = 'a';
84
		configurationValue = {
85
			default: { value: '1' },
86
			userLocal: { value: '2' },
87
			workspaceFolder: { value: '2' },
88
		};
89
		const resource = URI.file('someFile');
90

91
		await testObject.updateValue(resource, 'a', 'b', ConfigurationTarget.USER);
92
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.USER]);
93
	});
94

95
	test('updateValue writes into given workspace folder target with overrides', async () => {
96
		language = 'a';
97
		configurationValue = {
98
			default: { value: '1' },
99
			userLocal: { value: '2' },
100
			workspaceFolder: { value: '2', override: '1' },
101
			overrideIdentifiers: [language]
102
		};
103
		const resource = URI.file('someFile');
104

105
		await testObject.updateValue(resource, 'a', 'b', ConfigurationTarget.WORKSPACE_FOLDER);
106
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: language }, ConfigurationTarget.WORKSPACE_FOLDER]);
107
	});
108

109
	test('updateValue writes into derived workspace folder target without overrides', async () => {
110
		language = 'a';
111
		configurationValue = {
112
			default: { value: '1' },
113
			userLocal: { value: '2' },
114
			workspaceFolder: { value: '2' },
115
		};
116
		const resource = URI.file('someFile');
117

118
		await testObject.updateValue(resource, 'a', 'b');
119
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.WORKSPACE_FOLDER]);
120
	});
121

122
	test('updateValue writes into derived workspace folder target with overrides', async () => {
123
		language = 'a';
124
		configurationValue = {
125
			default: { value: '1' },
126
			userLocal: { value: '2' },
127
			workspace: { value: '2', override: '1' },
128
			workspaceFolder: { value: '2', override: '2' },
129
			overrideIdentifiers: [language]
130
		};
131
		const resource = URI.file('someFile');
132

133
		await testObject.updateValue(resource, 'a', 'b');
134
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: language }, ConfigurationTarget.WORKSPACE_FOLDER]);
135
	});
136

137
	test('updateValue writes into derived workspace target without overrides', async () => {
138
		language = 'a';
139
		configurationValue = {
140
			default: { value: '1' },
141
			userLocal: { value: '2' },
142
			workspace: { value: '2' },
143
		};
144
		const resource = URI.file('someFile');
145

146
		await testObject.updateValue(resource, 'a', 'b');
147
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.WORKSPACE]);
148
	});
149

150
	test('updateValue writes into derived workspace target with overrides', async () => {
151
		language = 'a';
152
		configurationValue = {
153
			default: { value: '1' },
154
			userLocal: { value: '2' },
155
			workspace: { value: '2', override: '2' },
156
			overrideIdentifiers: [language]
157
		};
158
		const resource = URI.file('someFile');
159

160
		await testObject.updateValue(resource, 'a', 'b');
161
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: language }, ConfigurationTarget.WORKSPACE]);
162
	});
163

164
	test('updateValue writes into derived workspace target with overrides and value defined in folder', async () => {
165
		language = 'a';
166
		configurationValue = {
167
			default: { value: '1', override: '3' },
168
			userLocal: { value: '2' },
169
			workspace: { value: '2', override: '2' },
170
			workspaceFolder: { value: '2' },
171
			overrideIdentifiers: [language]
172
		};
173
		const resource = URI.file('someFile');
174

175
		await testObject.updateValue(resource, 'a', 'b');
176
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: language }, ConfigurationTarget.WORKSPACE]);
177
	});
178

179
	test('updateValue writes into derived user remote target without overrides', async () => {
180
		language = 'a';
181
		configurationValue = {
182
			default: { value: '1' },
183
			userLocal: { value: '2' },
184
			userRemote: { value: '2' },
185
		};
186
		const resource = URI.file('someFile');
187

188
		await testObject.updateValue(resource, 'a', 'b');
189
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.USER_REMOTE]);
190
	});
191

192
	test('updateValue writes into derived user remote target with overrides', async () => {
193
		language = 'a';
194
		configurationValue = {
195
			default: { value: '1' },
196
			userLocal: { value: '2' },
197
			userRemote: { value: '2', override: '3' },
198
			overrideIdentifiers: [language]
199
		};
200
		const resource = URI.file('someFile');
201

202
		await testObject.updateValue(resource, 'a', 'b');
203
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_REMOTE]);
204
	});
205

206
	test('updateValue writes into derived user remote target with overrides and value defined in workspace', async () => {
207
		language = 'a';
208
		configurationValue = {
209
			default: { value: '1' },
210
			userLocal: { value: '2' },
211
			userRemote: { value: '2', override: '3' },
212
			workspace: { value: '3' },
213
			overrideIdentifiers: [language]
214
		};
215
		const resource = URI.file('someFile');
216

217
		await testObject.updateValue(resource, 'a', 'b');
218
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_REMOTE]);
219
	});
220

221
	test('updateValue writes into derived user remote target with overrides and value defined in workspace folder', async () => {
222
		language = 'a';
223
		configurationValue = {
224
			default: { value: '1' },
225
			userLocal: { value: '2', override: '1' },
226
			userRemote: { value: '2', override: '3' },
227
			workspace: { value: '3' },
228
			workspaceFolder: { value: '3' },
229
			overrideIdentifiers: [language]
230
		};
231
		const resource = URI.file('someFile');
232

233
		await testObject.updateValue(resource, 'a', 'b');
234
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_REMOTE]);
235
	});
236

237
	test('updateValue writes into derived user target without overrides', async () => {
238
		language = 'a';
239
		configurationValue = {
240
			default: { value: '1' },
241
			userLocal: { value: '2' },
242
		};
243
		const resource = URI.file('someFile');
244

245
		await testObject.updateValue(resource, 'a', 'b');
246
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.USER_LOCAL]);
247
	});
248

249
	test('updateValue writes into derived user target with overrides', async () => {
250
		language = 'a';
251
		configurationValue = {
252
			default: { value: '1' },
253
			userLocal: { value: '2', override: '3' },
254
			overrideIdentifiers: [language]
255
		};
256
		const resource = URI.file('someFile');
257

258
		await testObject.updateValue(resource, 'a', '2');
259
		assert.deepStrictEqual(updateArgs, ['a', '2', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_LOCAL]);
260
	});
261

262
	test('updateValue writes into derived user target with overrides and value is defined in remote', async () => {
263
		language = 'a';
264
		configurationValue = {
265
			default: { value: '1' },
266
			userLocal: { value: '2', override: '3' },
267
			userRemote: { value: '3' },
268
			overrideIdentifiers: [language]
269
		};
270
		const resource = URI.file('someFile');
271

272
		await testObject.updateValue(resource, 'a', '2');
273
		assert.deepStrictEqual(updateArgs, ['a', '2', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_LOCAL]);
274
	});
275

276
	test('updateValue writes into derived user target with overrides and value is defined in workspace', async () => {
277
		language = 'a';
278
		configurationValue = {
279
			default: { value: '1' },
280
			userLocal: { value: '2', override: '3' },
281
			workspaceValue: { value: '3' },
282
			overrideIdentifiers: [language]
283
		};
284
		const resource = URI.file('someFile');
285

286
		await testObject.updateValue(resource, 'a', '2');
287
		assert.deepStrictEqual(updateArgs, ['a', '2', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_LOCAL]);
288
	});
289

290
	test('updateValue writes into derived user target with overrides and value is defined in workspace folder', async () => {
291
		language = 'a';
292
		configurationValue = {
293
			default: { value: '1', override: '3' },
294
			userLocal: { value: '2', override: '3' },
295
			userRemote: { value: '3' },
296
			workspaceFolderValue: { value: '3' },
297
			overrideIdentifiers: [language]
298
		};
299
		const resource = URI.file('someFile');
300

301
		await testObject.updateValue(resource, 'a', '2');
302
		assert.deepStrictEqual(updateArgs, ['a', '2', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_LOCAL]);
303
	});
304

305
	test('updateValue writes into derived user target when overridden in default and not in user', async () => {
306
		language = 'a';
307
		configurationValue = {
308
			default: { value: '1', override: '3' },
309
			userLocal: { value: '2' },
310
			overrideIdentifiers: [language]
311
		};
312
		const resource = URI.file('someFile');
313

314
		await testObject.updateValue(resource, 'a', '2');
315
		assert.deepStrictEqual(updateArgs, ['a', '2', { resource, overrideIdentifier: language }, ConfigurationTarget.USER_LOCAL]);
316
	});
317

318
	test('updateValue when not changed', async () => {
319
		language = 'a';
320
		configurationValue = {
321
			default: { value: '1' },
322
		};
323
		const resource = URI.file('someFile');
324

325
		await testObject.updateValue(resource, 'a', 'b');
326
		assert.deepStrictEqual(updateArgs, ['a', 'b', { resource, overrideIdentifier: undefined }, ConfigurationTarget.USER_LOCAL]);
327
	});
328

329
});
330

331
Product

Resources

Company
