CoCalc -- notebookFolding.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/extensions/copilot/test/simulation/fixtures/tests/in-suite-issue-3701/notebookFolding.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 * as assert from 'assert';
7
import { DisposableStore } from 'vs/base/common/lifecycle';
8
import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
9
import { IUndoRedoService } from 'vs/platform/undoRedo/common/undoRedo';
10
import { FoldingModel, updateFoldingStateAtIndex } from 'vs/workbench/contrib/notebook/browser/viewModel/foldingModel';
11
import { CellKind } from 'vs/workbench/contrib/notebook/common/notebookCommon';
12
import { setupInstantiationService, withTestNotebook } from 'vs/workbench/contrib/notebook/test/browser/testNotebookEditor';
13

14
suite('Notebook Folding', () => {
15
	let disposables: DisposableStore;
16
	let instantiationService: TestInstantiationService;
17

18
	suiteSetup(() => {
19
		disposables = new DisposableStore();
20
		instantiationService = setupInstantiationService(disposables);
21
		instantiationService.spy(IUndoRedoService, 'pushElement');
22
	});
23

24
	suiteTeardown(() => disposables.dispose());
25

26
	test('Folding based on markdown cells', async function () {
27
		await withTestNotebook(
28
			[
29
				['# header 1', 'markdown', CellKind.Markup, [], {}],
30
				['body', 'markdown', CellKind.Markup, [], {}],
31
				['## header 2.1', 'markdown', CellKind.Markup, [], {}],
32
				['body 2', 'markdown', CellKind.Markup, [], {}],
33
				['body 3', 'markdown', CellKind.Markup, [], {}],
34
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
35
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
36
			],
37
			(editor, viewModel) => {
38
				const foldingController = new FoldingModel();
39
				foldingController.attachViewModel(viewModel);
40

41
				assert.strictEqual(foldingController.regions.findRange(1), 0);
42
				assert.strictEqual(foldingController.regions.findRange(2), 0);
43
				assert.strictEqual(foldingController.regions.findRange(3), 1);
44
				assert.strictEqual(foldingController.regions.findRange(4), 1);
45
				assert.strictEqual(foldingController.regions.findRange(5), 1);
46
				assert.strictEqual(foldingController.regions.findRange(6), 2);
47
				assert.strictEqual(foldingController.regions.findRange(7), 2);
48
			}
49
		);
50
	});
51

52
	test('Folding not based on code cells', async function () {
53
		await withTestNotebook(
54
			[
55
				['# header 1', 'markdown', CellKind.Markup, [], {}],
56
				['body', 'markdown', CellKind.Markup, [], {}],
57
				['# comment 1', 'python', CellKind.Code, [], {}],
58
				['body 2', 'markdown', CellKind.Markup, [], {}],
59
				['body 3\n```\n## comment 2\n```', 'markdown', CellKind.Markup, [], {}],
60
				['body 4', 'markdown', CellKind.Markup, [], {}],
61
				['## header 2.1', 'markdown', CellKind.Markup, [], {}],
62
				['var e = 7;', 'python', CellKind.Code, [], {}],
63
			],
64
			(editor, viewModel) => {
65
				const foldingController = new FoldingModel();
66
				foldingController.attachViewModel(viewModel);
67

68
				assert.strictEqual(foldingController.regions.findRange(1), 0);
69
				assert.strictEqual(foldingController.regions.findRange(2), 0);
70
				assert.strictEqual(foldingController.regions.findRange(3), 0);
71
				assert.strictEqual(foldingController.regions.findRange(4), 0);
72
				assert.strictEqual(foldingController.regions.findRange(5), 0);
73
				assert.strictEqual(foldingController.regions.findRange(6), 0);
74
				assert.strictEqual(foldingController.regions.findRange(7), 1);
75
				assert.strictEqual(foldingController.regions.findRange(8), 1);
76
			}
77
		);
78
	});
79

80
	test('Top level header in a cell wins', async function () {
81
		await withTestNotebook(
82
			[
83
				['# header 1', 'markdown', CellKind.Markup, [], {}],
84
				['body', 'markdown', CellKind.Markup, [], {}],
85
				['## header 2.1\n# header3', 'markdown', CellKind.Markup, [], {}],
86
				['body 2', 'markdown', CellKind.Markup, [], {}],
87
				['body 3', 'markdown', CellKind.Markup, [], {}],
88
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
89
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
90
			],
91
			(editor, viewModel) => {
92
				const foldingController = new FoldingModel();
93
				foldingController.attachViewModel(viewModel);
94

95
				assert.strictEqual(foldingController.regions.findRange(1), 0);
96
				assert.strictEqual(foldingController.regions.findRange(2), 0);
97
				assert.strictEqual(foldingController.regions.getEndLineNumber(0), 2);
98

99
				assert.strictEqual(foldingController.regions.findRange(3), 1);
100
				assert.strictEqual(foldingController.regions.findRange(4), 1);
101
				assert.strictEqual(foldingController.regions.findRange(5), 1);
102
				assert.strictEqual(foldingController.regions.getEndLineNumber(1), 7);
103

104
				assert.strictEqual(foldingController.regions.findRange(6), 2);
105
				assert.strictEqual(foldingController.regions.findRange(7), 2);
106
				assert.strictEqual(foldingController.regions.getEndLineNumber(2), 7);
107
			}
108
		);
109
	});
110

111
	test('Folding', async function () {
112
		await withTestNotebook(
113
			[
114
				['# header 1', 'markdown', CellKind.Markup, [], {}],
115
				['body', 'markdown', CellKind.Markup, [], {}],
116
				['## header 2.1', 'markdown', CellKind.Markup, [], {}],
117
				['body 2', 'markdown', CellKind.Markup, [], {}],
118
				['body 3', 'markdown', CellKind.Markup, [], {}],
119
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
120
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
121
			],
122
			(editor, viewModel) => {
123
				const foldingModel = new FoldingModel();
124
				foldingModel.attachViewModel(viewModel);
125
				updateFoldingStateAtIndex(foldingModel, 0, true);
126
				viewModel.updateFoldingRanges(foldingModel.regions);
127
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
128
					{ start: 1, end: 6 }
129
				]);
130
			}
131
		);
132

133

134

135
		await withTestNotebook(
136
			[
137
				['# header 1', 'markdown', CellKind.Markup, [], {}],
138
				['body', 'markdown', CellKind.Markup, [], {}],
139
				['## header 2.1\n', 'markdown', CellKind.Markup, [], {}],
140
				['body 2', 'markdown', CellKind.Markup, [], {}],
141
				['body 3', 'markdown', CellKind.Markup, [], {}],
142
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
143
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
144
			],
145
			(editor, viewModel) => {
146
				const foldingModel = new FoldingModel();
147
				foldingModel.attachViewModel(viewModel);
148
				updateFoldingStateAtIndex(foldingModel, 2, true);
149
				viewModel.updateFoldingRanges(foldingModel.regions);
150

151
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
152
					{ start: 3, end: 4 }
153
				]);
154
			}
155
		);
156

157
		await withTestNotebook(
158
			[
159
				['# header 1', 'markdown', CellKind.Markup, [], {}],
160
				['body', 'markdown', CellKind.Markup, [], {}],
161
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
162
				['body 2', 'markdown', CellKind.Markup, [], {}],
163
				['body 3', 'markdown', CellKind.Markup, [], {}],
164
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
165
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
166
			],
167
			(editor, viewModel) => {
168
				const foldingModel = new FoldingModel();
169
				foldingModel.attachViewModel(viewModel);
170
				updateFoldingStateAtIndex(foldingModel, 2, true);
171
				viewModel.updateFoldingRanges(foldingModel.regions);
172

173
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
174
					{ start: 3, end: 6 }
175
				]);
176
			}
177
		);
178
	});
179

180
	test('Nested Folding', async function () {
181
		await withTestNotebook(
182
			[
183
				['# header 1', 'markdown', CellKind.Markup, [], {}],
184
				['body', 'markdown', CellKind.Markup, [], {}],
185
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
186
				['body 2', 'markdown', CellKind.Markup, [], {}],
187
				['body 3', 'markdown', CellKind.Markup, [], {}],
188
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
189
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
190
			],
191
			(editor, viewModel) => {
192
				const foldingModel = new FoldingModel();
193
				foldingModel.attachViewModel(viewModel);
194
				updateFoldingStateAtIndex(foldingModel, 0, true);
195
				viewModel.updateFoldingRanges(foldingModel.regions);
196

197
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
198
					{ start: 1, end: 1 }
199
				]);
200

201
				updateFoldingStateAtIndex(foldingModel, 5, true);
202
				updateFoldingStateAtIndex(foldingModel, 2, true);
203
				viewModel.updateFoldingRanges(foldingModel.regions);
204

205
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
206
					{ start: 1, end: 1 },
207
					{ start: 3, end: 6 }
208
				]);
209

210
				updateFoldingStateAtIndex(foldingModel, 2, false);
211
				viewModel.updateFoldingRanges(foldingModel.regions);
212
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
213
					{ start: 1, end: 1 },
214
					{ start: 6, end: 6 }
215
				]);
216

217
				// viewModel.insertCell(7, new TestCell(viewModel.viewType, 7, ['var c = 8;'], 'markdown', CellKind.Code, []), true);
218

219
				// assert.deepStrictEqual(viewModel.getHiddenRanges(), [
220
				// 	{ start: 1, end: 1 },
221
				// 	{ start: 6, end: 7 }
222
				// ]);
223

224
				// viewModel.insertCell(1, new TestCell(viewModel.viewType, 8, ['var c = 9;'], 'markdown', CellKind.Code, []), true);
225
				// assert.deepStrictEqual(viewModel.getHiddenRanges(), [
226
				// 	// the first collapsed range is now expanded as we insert content into it.
227
				// 	// { start: 1,},
228
				// 	{ start: 7, end: 8 }
229
				// ]);
230
			}
231
		);
232
	});
233

234
	test('Folding Memento', async function () {
235
		await withTestNotebook(
236
			[
237
				['# header 1', 'markdown', CellKind.Markup, [], {}],
238
				['body', 'markdown', CellKind.Markup, [], {}],
239
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
240
				['body 2', 'markdown', CellKind.Markup, [], {}],
241
				['body 3', 'markdown', CellKind.Markup, [], {}],
242
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
243
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
244
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
245
				['body 2', 'markdown', CellKind.Markup, [], {}],
246
				['body 3', 'markdown', CellKind.Markup, [], {}],
247
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
248
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
249
			],
250
			(editor, viewModel) => {
251
				const foldingModel = new FoldingModel();
252
				foldingModel.attachViewModel(viewModel);
253
				foldingModel.applyMemento([{ start: 2, end: 6 }]);
254
				viewModel.updateFoldingRanges(foldingModel.regions);
255

256
				// Note that hidden ranges !== folding ranges
257
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
258
					{ start: 3, end: 6 }
259
				]);
260
			}
261
		);
262

263
		await withTestNotebook(
264
			[
265
				['# header 1', 'markdown', CellKind.Markup, [], {}],
266
				['body', 'markdown', CellKind.Markup, [], {}],
267
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
268
				['body 2', 'markdown', CellKind.Markup, [], {}],
269
				['body 3', 'markdown', CellKind.Markup, [], {}],
270
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
271
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
272
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
273
				['body 2', 'markdown', CellKind.Markup, [], {}],
274
				['body 3', 'markdown', CellKind.Markup, [], {}],
275
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
276
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
277
			],
278
			(editor, viewModel) => {
279
				const foldingModel = new FoldingModel();
280
				foldingModel.attachViewModel(viewModel);
281
				foldingModel.applyMemento([
282
					{ start: 5, end: 6 },
283
					{ start: 10, end: 11 },
284
				]);
285
				viewModel.updateFoldingRanges(foldingModel.regions);
286

287
				// Note that hidden ranges !== folding ranges
288
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
289
					{ start: 6, end: 6 },
290
					{ start: 11, end: 11 }
291
				]);
292
			}
293
		);
294

295
		await withTestNotebook(
296
			[
297
				['# header 1', 'markdown', CellKind.Markup, [], {}],
298
				['body', 'markdown', CellKind.Markup, [], {}],
299
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
300
				['body 2', 'markdown', CellKind.Markup, [], {}],
301
				['body 3', 'markdown', CellKind.Markup, [], {}],
302
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
303
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
304
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
305
				['body 2', 'markdown', CellKind.Markup, [], {}],
306
				['body 3', 'markdown', CellKind.Markup, [], {}],
307
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
308
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
309
			],
310
			(editor, viewModel) => {
311
				const foldingModel = new FoldingModel();
312
				foldingModel.attachViewModel(viewModel);
313
				foldingModel.applyMemento([
314
					{ start: 5, end: 6 },
315
					{ start: 7, end: 11 },
316
				]);
317
				viewModel.updateFoldingRanges(foldingModel.regions);
318

319
				// Note that hidden ranges !== folding ranges
320
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
321
					{ start: 6, end: 6 },
322
					{ start: 8, end: 11 }
323
				]);
324
			}
325
		);
326
	});
327

328
	test('View Index', async function () {
329
		await withTestNotebook(
330
			[
331
				['# header 1', 'markdown', CellKind.Markup, [], {}],
332
				['body', 'markdown', CellKind.Markup, [], {}],
333
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
334
				['body 2', 'markdown', CellKind.Markup, [], {}],
335
				['body 3', 'markdown', CellKind.Markup, [], {}],
336
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
337
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
338
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
339
				['body 2', 'markdown', CellKind.Markup, [], {}],
340
				['body 3', 'markdown', CellKind.Markup, [], {}],
341
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
342
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
343
			],
344
			(editor, viewModel) => {
345
				const foldingModel = new FoldingModel();
346
				foldingModel.attachViewModel(viewModel);
347
				foldingModel.applyMemento([{ start: 2, end: 6 }]);
348
				viewModel.updateFoldingRanges(foldingModel.regions);
349

350
				// Note that hidden ranges !== folding ranges
351
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
352
					{ start: 3, end: 6 }
353
				]);
354

355
				assert.strictEqual(viewModel.getNextVisibleCellIndex(1), 2);
356
				assert.strictEqual(viewModel.getNextVisibleCellIndex(2), 7);
357
				assert.strictEqual(viewModel.getNextVisibleCellIndex(3), 7);
358
				assert.strictEqual(viewModel.getNextVisibleCellIndex(4), 7);
359
				assert.strictEqual(viewModel.getNextVisibleCellIndex(5), 7);
360
				assert.strictEqual(viewModel.getNextVisibleCellIndex(6), 7);
361
				assert.strictEqual(viewModel.getNextVisibleCellIndex(7), 8);
362
			}
363
		);
364

365
		await withTestNotebook(
366
			[
367
				['# header 1', 'markdown', CellKind.Markup, [], {}],
368
				['body', 'markdown', CellKind.Markup, [], {}],
369
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
370
				['body 2', 'markdown', CellKind.Markup, [], {}],
371
				['body 3', 'markdown', CellKind.Markup, [], {}],
372
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
373
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
374
				['# header 2.1\n', 'markdown', CellKind.Markup, [], {}],
375
				['body 2', 'markdown', CellKind.Markup, [], {}],
376
				['body 3', 'markdown', CellKind.Markup, [], {}],
377
				['## header 2.2', 'markdown', CellKind.Markup, [], {}],
378
				['var e = 7;', 'markdown', CellKind.Markup, [], {}],
379
			],
380
			(editor, viewModel) => {
381
				const foldingModel = new FoldingModel();
382
				foldingModel.attachViewModel(viewModel);
383
				foldingModel.applyMemento([
384
					{ start: 5, end: 6 },
385
					{ start: 10, end: 11 },
386
				]);
387

388
				viewModel.updateFoldingRanges(foldingModel.regions);
389

390
				// Note that hidden ranges !== folding ranges
391
				assert.deepStrictEqual(viewModel.getHiddenRanges(), [
392
					{ start: 6, end: 6 },
393
					{ start: 11, end: 11 }
394
				]);
395

396
				// folding ranges
397
				// [5, 6]
398
				// [10, 11]
399
				assert.strictEqual(viewModel.getNextVisibleCellIndex(4), 5);
400
				assert.strictEqual(viewModel.getNextVisibleCellIndex(5), 7);
401
				assert.strictEqual(viewModel.getNextVisibleCellIndex(6), 7);
402

403
				assert.strictEqual(viewModel.getNextVisibleCellIndex(9), 10);
404
				assert.strictEqual(viewModel.getNextVisibleCellIndex(10), 12);
405
				assert.strictEqual(viewModel.getNextVisibleCellIndex(11), 12);
406
			}
407
		);
408
	});
409
});
410

411
Product

Resources

Company
