CoCalc -- settingsTreeModels.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/contrib/preferences/test/browser/settingsTreeModels.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 { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
8
import { settingKeyToDisplayFormat, parseQuery, IParsedQuery } from '../../browser/settingsTreeModels.js';
9

10
suite('SettingsTree', () => {
11
	test('settingKeyToDisplayFormat', () => {
12
		assert.deepStrictEqual(
13
			settingKeyToDisplayFormat('foo.bar'),
14
			{
15
				category: 'Foo',
16
				label: 'Bar'
17
			});
18

19
		assert.deepStrictEqual(
20
			settingKeyToDisplayFormat('foo.bar.etc'),
21
			{
22
				category: 'Foo › Bar',
23
				label: 'Etc'
24
			});
25

26
		assert.deepStrictEqual(
27
			settingKeyToDisplayFormat('fooBar.etcSomething'),
28
			{
29
				category: 'Foo Bar',
30
				label: 'Etc Something'
31
			});
32

33
		assert.deepStrictEqual(
34
			settingKeyToDisplayFormat('foo'),
35
			{
36
				category: '',
37
				label: 'Foo'
38
			});
39

40
		assert.deepStrictEqual(
41
			settingKeyToDisplayFormat('foo.1leading.number'),
42
			{
43
				category: 'Foo › 1leading',
44
				label: 'Number'
45
			});
46

47
		assert.deepStrictEqual(
48
			settingKeyToDisplayFormat('foo.1Leading.number'),
49
			{
50
				category: 'Foo › 1 Leading',
51
				label: 'Number'
52
			});
53
	});
54

55
	test('settingKeyToDisplayFormat - with category', () => {
56
		assert.deepStrictEqual(
57
			settingKeyToDisplayFormat('foo.bar', 'foo'),
58
			{
59
				category: '',
60
				label: 'Bar'
61
			});
62

63
		assert.deepStrictEqual(
64
			settingKeyToDisplayFormat('disableligatures.ligatures', 'disableligatures'),
65
			{
66
				category: '',
67
				label: 'Ligatures'
68
			});
69

70
		assert.deepStrictEqual(
71
			settingKeyToDisplayFormat('foo.bar.etc', 'foo'),
72
			{
73
				category: 'Bar',
74
				label: 'Etc'
75
			});
76

77
		assert.deepStrictEqual(
78
			settingKeyToDisplayFormat('fooBar.etcSomething', 'foo'),
79
			{
80
				category: 'Foo Bar',
81
				label: 'Etc Something'
82
			});
83

84
		assert.deepStrictEqual(
85
			settingKeyToDisplayFormat('foo.bar.etc', 'foo/bar'),
86
			{
87
				category: '',
88
				label: 'Etc'
89
			});
90

91
		assert.deepStrictEqual(
92
			settingKeyToDisplayFormat('foo.bar.etc', 'something/foo'),
93
			{
94
				category: 'Bar',
95
				label: 'Etc'
96
			});
97

98
		assert.deepStrictEqual(
99
			settingKeyToDisplayFormat('bar.etc', 'something.bar'),
100
			{
101
				category: '',
102
				label: 'Etc'
103
			});
104

105
		assert.deepStrictEqual(
106
			settingKeyToDisplayFormat('fooBar.etc', 'fooBar'),
107
			{
108
				category: '',
109
				label: 'Etc'
110
			});
111

112

113
		assert.deepStrictEqual(
114
			settingKeyToDisplayFormat('fooBar.somethingElse.etc', 'fooBar'),
115
			{
116
				category: 'Something Else',
117
				label: 'Etc'
118
			});
119
	});
120

121
	test('settingKeyToDisplayFormat - known acronym/term', () => {
122
		assert.deepStrictEqual(
123
			settingKeyToDisplayFormat('css.someCssSetting'),
124
			{
125
				category: 'CSS',
126
				label: 'Some CSS Setting'
127
			});
128

129
		assert.deepStrictEqual(
130
			settingKeyToDisplayFormat('powershell.somePowerShellSetting'),
131
			{
132
				category: 'PowerShell',
133
				label: 'Some PowerShell Setting'
134
			});
135
	});
136

137
	test('parseQuery', () => {
138
		function testParseQuery(input: string, expected: IParsedQuery) {
139
			assert.deepStrictEqual(
140
				parseQuery(input),
141
				expected,
142
				input
143
			);
144
		}
145

146
		testParseQuery(
147
			'',
148
			<IParsedQuery>{
149
				tags: [],
150
				extensionFilters: [],
151
				query: '',
152
				featureFilters: [],
153
				idFilters: [],
154
				languageFilter: undefined
155
			});
156

157
		testParseQuery(
158
			'@modified',
159
			<IParsedQuery>{
160
				tags: ['modified'],
161
				extensionFilters: [],
162
				query: '',
163
				featureFilters: [],
164
				idFilters: [],
165
				languageFilter: undefined
166
			});
167

168
		testParseQuery(
169
			'@tag:foo',
170
			<IParsedQuery>{
171
				tags: ['foo'],
172
				extensionFilters: [],
173
				query: '',
174
				featureFilters: [],
175
				idFilters: [],
176
				languageFilter: undefined
177
			});
178

179
		testParseQuery(
180
			'@modified foo',
181
			<IParsedQuery>{
182
				tags: ['modified'],
183
				extensionFilters: [],
184
				query: 'foo',
185
				featureFilters: [],
186
				idFilters: [],
187
				languageFilter: undefined
188
			});
189

190
		testParseQuery(
191
			'@tag:foo @modified',
192
			<IParsedQuery>{
193
				tags: ['foo', 'modified'],
194
				extensionFilters: [],
195
				query: '',
196
				featureFilters: [],
197
				idFilters: [],
198
				languageFilter: undefined
199
			});
200

201
		testParseQuery(
202
			'@tag:foo @modified my query',
203
			<IParsedQuery>{
204
				tags: ['foo', 'modified'],
205
				extensionFilters: [],
206
				query: 'my query',
207
				featureFilters: [],
208
				idFilters: [],
209
				languageFilter: undefined
210
			});
211

212
		testParseQuery(
213
			'test @modified query',
214
			<IParsedQuery>{
215
				tags: ['modified'],
216
				extensionFilters: [],
217
				query: 'test  query',
218
				featureFilters: [],
219
				idFilters: [],
220
				languageFilter: undefined
221
			});
222

223
		testParseQuery(
224
			'test @modified',
225
			<IParsedQuery>{
226
				tags: ['modified'],
227
				extensionFilters: [],
228
				query: 'test',
229
				featureFilters: [],
230
				idFilters: [],
231
				languageFilter: undefined
232
			});
233

234
		testParseQuery(
235
			'query has @ for some reason',
236
			<IParsedQuery>{
237
				tags: [],
238
				extensionFilters: [],
239
				query: 'query has @ for some reason',
240
				featureFilters: [],
241
				idFilters: [],
242
				languageFilter: undefined
243
			});
244

245
		testParseQuery(
246
			'@ext:github.vscode-pull-request-github',
247
			<IParsedQuery>{
248
				tags: [],
249
				extensionFilters: ['github.vscode-pull-request-github'],
250
				query: '',
251
				featureFilters: [],
252
				idFilters: [],
253
				languageFilter: undefined
254
			});
255

256
		testParseQuery(
257
			'@ext:github.vscode-pull-request-github,vscode.git',
258
			<IParsedQuery>{
259
				tags: [],
260
				extensionFilters: ['github.vscode-pull-request-github', 'vscode.git'],
261
				query: '',
262
				featureFilters: [],
263
				idFilters: [],
264
				languageFilter: undefined
265
			});
266
		testParseQuery(
267
			'@feature:scm',
268
			<IParsedQuery>{
269
				tags: [],
270
				extensionFilters: [],
271
				featureFilters: ['scm'],
272
				query: '',
273
				idFilters: [],
274
				languageFilter: undefined
275
			});
276

277
		testParseQuery(
278
			'@feature:scm,terminal',
279
			<IParsedQuery>{
280
				tags: [],
281
				extensionFilters: [],
282
				featureFilters: ['scm', 'terminal'],
283
				query: '',
284
				idFilters: [],
285
				languageFilter: undefined
286
			});
287
		testParseQuery(
288
			'@id:files.autoSave',
289
			<IParsedQuery>{
290
				tags: [],
291
				extensionFilters: [],
292
				featureFilters: [],
293
				query: '',
294
				idFilters: ['files.autoSave'],
295
				languageFilter: undefined
296
			});
297

298
		testParseQuery(
299
			'@id:files.autoSave,terminal.integrated.commandsToSkipShell',
300
			<IParsedQuery>{
301
				tags: [],
302
				extensionFilters: [],
303
				featureFilters: [],
304
				query: '',
305
				idFilters: ['files.autoSave', 'terminal.integrated.commandsToSkipShell'],
306
				languageFilter: undefined
307
			});
308

309
		testParseQuery(
310
			'@lang:cpp',
311
			<IParsedQuery>{
312
				tags: [],
313
				extensionFilters: [],
314
				featureFilters: [],
315
				query: '',
316
				idFilters: [],
317
				languageFilter: 'cpp'
318
			});
319

320
		testParseQuery(
321
			'@lang:cpp,python',
322
			<IParsedQuery>{
323
				tags: [],
324
				extensionFilters: [],
325
				featureFilters: [],
326
				query: '',
327
				idFilters: [],
328
				languageFilter: 'cpp'
329
			});
330
	});
331

332
	ensureNoDisposablesAreLeakedInTestSuite();
333
});
334

335
Product

Resources

Company
