CoCalc -- indexedDBFileService.integrationTest.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/platform/files/test/browser/indexedDBFileService.integrationTest.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 { IndexedDB } from '../../../../base/browser/indexedDB.js';
8
import { bufferToReadable, bufferToStream, VSBuffer, VSBufferReadable, VSBufferReadableStream } from '../../../../base/common/buffer.js';
9
import { DisposableStore } from '../../../../base/common/lifecycle.js';
10
import { Schemas } from '../../../../base/common/network.js';
11
import { basename, joinPath } from '../../../../base/common/resources.js';
12
import { URI } from '../../../../base/common/uri.js';
13
import { flakySuite } from '../../../../base/test/common/testUtils.js';
14
import { IndexedDBFileSystemProvider } from '../../browser/indexedDBFileSystemProvider.js';
15
import { FileOperation, FileOperationError, FileOperationEvent, FileOperationResult, FileSystemProviderError, FileSystemProviderErrorCode, FileType } from '../../common/files.js';
16
import { FileService } from '../../common/fileService.js';
17
import { NullLogService } from '../../../log/common/log.js';
18

19
flakySuite('IndexedDBFileSystemProvider', function () {
20

21
	let service: FileService;
22
	let userdataFileProvider: IndexedDBFileSystemProvider;
23
	const testDir = '/';
24

25
	const userdataURIFromPaths = (paths: readonly string[]) => joinPath(URI.from({ scheme: Schemas.vscodeUserData, path: testDir }), ...paths);
26

27
	const disposables = new DisposableStore();
28

29
	const initFixtures = async () => {
30
		await Promise.all(
31
			[['fixtures', 'resolver', 'examples'],
32
			['fixtures', 'resolver', 'other', 'deep'],
33
			['fixtures', 'service', 'deep'],
34
			['batched']]
35
				.map(path => userdataURIFromPaths(path))
36
				.map(uri => service.createFolder(uri)));
37
		await Promise.all(
38
			([
39
				[['fixtures', 'resolver', 'examples', 'company.js'], 'class company {}'],
40
				[['fixtures', 'resolver', 'examples', 'conway.js'], 'export function conway() {}'],
41
				[['fixtures', 'resolver', 'examples', 'employee.js'], 'export const employee = "jax"'],
42
				[['fixtures', 'resolver', 'examples', 'small.js'], ''],
43
				[['fixtures', 'resolver', 'other', 'deep', 'company.js'], 'class company {}'],
44
				[['fixtures', 'resolver', 'other', 'deep', 'conway.js'], 'export function conway() {}'],
45
				[['fixtures', 'resolver', 'other', 'deep', 'employee.js'], 'export const employee = "jax"'],
46
				[['fixtures', 'resolver', 'other', 'deep', 'small.js'], ''],
47
				[['fixtures', 'resolver', 'index.html'], '<p>p</p>'],
48
				[['fixtures', 'resolver', 'site.css'], '.p {color: red;}'],
49
				[['fixtures', 'service', 'deep', 'company.js'], 'class company {}'],
50
				[['fixtures', 'service', 'deep', 'conway.js'], 'export function conway() {}'],
51
				[['fixtures', 'service', 'deep', 'employee.js'], 'export const employee = "jax"'],
52
				[['fixtures', 'service', 'deep', 'small.js'], ''],
53
				[['fixtures', 'service', 'binary.txt'], '<p>p</p>'],
54
			] as const)
55
				.map(([path, contents]) => [userdataURIFromPaths(path), contents] as const)
56
				.map(([uri, contents]) => service.createFile(uri, VSBuffer.fromString(contents)))
57
		);
58
	};
59

60
	const reload = async () => {
61
		const logService = new NullLogService();
62

63
		service = new FileService(logService);
64
		disposables.add(service);
65

66
		const indexedDB = await IndexedDB.create('vscode-web-db-test', 1, ['vscode-userdata-store', 'vscode-logs-store']);
67

68
		userdataFileProvider = new IndexedDBFileSystemProvider(Schemas.vscodeUserData, indexedDB, 'vscode-userdata-store', true);
69
		disposables.add(service.registerProvider(Schemas.vscodeUserData, userdataFileProvider));
70
		disposables.add(userdataFileProvider);
71
	};
72

73
	setup(async function () {
74
		this.timeout(15000);
75
		await reload();
76
	});
77

78
	teardown(async () => {
79
		await userdataFileProvider.reset();
80
		disposables.clear();
81
	});
82

83
	test('root is always present', async () => {
84
		assert.strictEqual((await userdataFileProvider.stat(userdataURIFromPaths([]))).type, FileType.Directory);
85
		await userdataFileProvider.delete(userdataURIFromPaths([]), { recursive: true, useTrash: false, atomic: false });
86
		assert.strictEqual((await userdataFileProvider.stat(userdataURIFromPaths([]))).type, FileType.Directory);
87
	});
88

89
	test('createFolder', async () => {
90
		let event: FileOperationEvent | undefined;
91
		disposables.add(service.onDidRunOperation(e => event = e));
92

93
		const parent = await service.resolve(userdataURIFromPaths([]));
94
		const newFolderResource = joinPath(parent.resource, 'newFolder');
95

96
		assert.strictEqual((await userdataFileProvider.readdir(parent.resource)).length, 0);
97
		const newFolder = await service.createFolder(newFolderResource);
98
		assert.strictEqual(newFolder.name, 'newFolder');
99
		assert.strictEqual((await userdataFileProvider.readdir(parent.resource)).length, 1);
100
		assert.strictEqual((await userdataFileProvider.stat(newFolderResource)).type, FileType.Directory);
101

102
		assert.ok(event);
103
		assert.strictEqual(event.resource.path, newFolderResource.path);
104
		assert.strictEqual(event.operation, FileOperation.CREATE);
105
		assert.strictEqual(event.target!.resource.path, newFolderResource.path);
106
		assert.strictEqual(event.target!.isDirectory, true);
107
	});
108

109
	test('createFolder: creating multiple folders at once', async () => {
110
		let event: FileOperationEvent;
111
		disposables.add(service.onDidRunOperation(e => event = e));
112

113
		const multiFolderPaths = ['a', 'couple', 'of', 'folders'];
114
		const parent = await service.resolve(userdataURIFromPaths([]));
115
		const newFolderResource = joinPath(parent.resource, ...multiFolderPaths);
116

117
		const newFolder = await service.createFolder(newFolderResource);
118

119
		const lastFolderName = multiFolderPaths[multiFolderPaths.length - 1];
120
		assert.strictEqual(newFolder.name, lastFolderName);
121
		assert.strictEqual((await userdataFileProvider.stat(newFolderResource)).type, FileType.Directory);
122

123
		assert.ok(event!);
124
		assert.strictEqual(event!.resource.path, newFolderResource.path);
125
		assert.strictEqual(event!.operation, FileOperation.CREATE);
126
		assert.strictEqual(event!.target!.resource.path, newFolderResource.path);
127
		assert.strictEqual(event!.target!.isDirectory, true);
128
	});
129

130
	test('exists', async () => {
131
		let exists = await service.exists(userdataURIFromPaths([]));
132
		assert.strictEqual(exists, true);
133

134
		exists = await service.exists(userdataURIFromPaths(['hello']));
135
		assert.strictEqual(exists, false);
136
	});
137

138
	test('resolve - file', async () => {
139
		await initFixtures();
140

141
		const resource = userdataURIFromPaths(['fixtures', 'resolver', 'index.html']);
142
		const resolved = await service.resolve(resource);
143

144
		assert.strictEqual(resolved.name, 'index.html');
145
		assert.strictEqual(resolved.isFile, true);
146
		assert.strictEqual(resolved.isDirectory, false);
147
		assert.strictEqual(resolved.isSymbolicLink, false);
148
		assert.strictEqual(resolved.resource.toString(), resource.toString());
149
		assert.strictEqual(resolved.children, undefined);
150
		assert.ok(resolved.size! > 0);
151
	});
152

153
	test('resolve - directory', async () => {
154
		await initFixtures();
155

156
		const testsElements = ['examples', 'other', 'index.html', 'site.css'];
157

158
		const resource = userdataURIFromPaths(['fixtures', 'resolver']);
159
		const result = await service.resolve(resource);
160

161
		assert.ok(result);
162
		assert.strictEqual(result.resource.toString(), resource.toString());
163
		assert.strictEqual(result.name, 'resolver');
164
		assert.ok(result.children);
165
		assert.ok(result.children.length > 0);
166
		assert.ok(result.isDirectory);
167
		assert.strictEqual(result.children.length, testsElements.length);
168

169
		assert.ok(result.children.every(entry => {
170
			return testsElements.some(name => {
171
				return basename(entry.resource) === name;
172
			});
173
		}));
174

175
		result.children.forEach(value => {
176
			assert.ok(basename(value.resource));
177
			if (['examples', 'other'].indexOf(basename(value.resource)) >= 0) {
178
				assert.ok(value.isDirectory);
179
				assert.strictEqual(value.mtime, undefined);
180
				assert.strictEqual(value.ctime, undefined);
181
			} else if (basename(value.resource) === 'index.html') {
182
				assert.ok(!value.isDirectory);
183
				assert.ok(!value.children);
184
				assert.strictEqual(value.mtime, undefined);
185
				assert.strictEqual(value.ctime, undefined);
186
			} else if (basename(value.resource) === 'site.css') {
187
				assert.ok(!value.isDirectory);
188
				assert.ok(!value.children);
189
				assert.strictEqual(value.mtime, undefined);
190
				assert.strictEqual(value.ctime, undefined);
191
			} else {
192
				assert.fail('Unexpected value ' + basename(value.resource));
193
			}
194
		});
195
	});
196

197
	test('createFile', async () => {
198
		return assertCreateFile(contents => VSBuffer.fromString(contents));
199
	});
200

201
	test('createFile (readable)', async () => {
202
		return assertCreateFile(contents => bufferToReadable(VSBuffer.fromString(contents)));
203
	});
204

205
	test('createFile (stream)', async () => {
206
		return assertCreateFile(contents => bufferToStream(VSBuffer.fromString(contents)));
207
	});
208

209
	async function assertCreateFile(converter: (content: string) => VSBuffer | VSBufferReadable | VSBufferReadableStream): Promise<void> {
210
		let event: FileOperationEvent;
211
		disposables.add(service.onDidRunOperation(e => event = e));
212

213
		const contents = 'Hello World';
214
		const resource = userdataURIFromPaths(['test.txt']);
215

216
		assert.strictEqual(await service.canCreateFile(resource), true);
217
		const fileStat = await service.createFile(resource, converter(contents));
218
		assert.strictEqual(fileStat.name, 'test.txt');
219
		assert.strictEqual((await userdataFileProvider.stat(fileStat.resource)).type, FileType.File);
220
		assert.strictEqual(new TextDecoder().decode(await userdataFileProvider.readFile(fileStat.resource)), contents);
221

222
		assert.ok(event!);
223
		assert.strictEqual(event!.resource.path, resource.path);
224
		assert.strictEqual(event!.operation, FileOperation.CREATE);
225
		assert.strictEqual(event!.target!.resource.path, resource.path);
226
	}
227

228
	const fileCreateBatchTester = (size: number, name: string) => {
229
		const batch = Array.from({ length: size }).map((_, i) => ({ contents: `Hello${i}`, resource: userdataURIFromPaths(['batched', name, `Hello${i}.txt`]) }));
230
		let creationPromises: Promise<any> | undefined = undefined;
231
		return {
232
			async create() {
233
				return creationPromises = Promise.all(batch.map(entry => userdataFileProvider.writeFile(entry.resource, VSBuffer.fromString(entry.contents).buffer, { create: true, overwrite: true, unlock: false, atomic: false })));
234
			},
235
			async assertContentsCorrect() {
236
				if (!creationPromises) { throw Error('read called before create'); }
237
				await creationPromises;
238
				await Promise.all(batch.map(async (entry, i) => {
239
					assert.strictEqual((await userdataFileProvider.stat(entry.resource)).type, FileType.File);
240
					assert.strictEqual(new TextDecoder().decode(await userdataFileProvider.readFile(entry.resource)), entry.contents);
241
				}));
242
			}
243
		};
244
	};
245

246
	test('createFile - batch', async () => {
247
		const tester = fileCreateBatchTester(20, 'batch');
248
		await tester.create();
249
		await tester.assertContentsCorrect();
250
	});
251

252
	test('createFile - batch (mixed parallel/sequential)', async () => {
253
		const batch1 = fileCreateBatchTester(1, 'batch1');
254
		const batch2 = fileCreateBatchTester(20, 'batch2');
255
		const batch3 = fileCreateBatchTester(1, 'batch3');
256
		const batch4 = fileCreateBatchTester(20, 'batch4');
257

258
		batch1.create();
259
		batch2.create();
260
		await Promise.all([batch1.assertContentsCorrect(), batch2.assertContentsCorrect()]);
261
		batch3.create();
262
		batch4.create();
263
		await Promise.all([batch3.assertContentsCorrect(), batch4.assertContentsCorrect()]);
264
		await Promise.all([batch1.assertContentsCorrect(), batch2.assertContentsCorrect()]);
265
	});
266

267
	test('rename not existing resource', async () => {
268
		const parent = await service.resolve(userdataURIFromPaths([]));
269
		const sourceFile = joinPath(parent.resource, 'sourceFile');
270
		const targetFile = joinPath(parent.resource, 'targetFile');
271

272
		try {
273
			await service.move(sourceFile, targetFile, false);
274
		} catch (error) {
275
			assert.deepStrictEqual((<FileSystemProviderError>error).code, FileSystemProviderErrorCode.FileNotFound);
276
			return;
277
		}
278

279
		assert.fail('This should fail with error');
280
	});
281

282
	test('rename to an existing file without overwrite', async () => {
283
		const parent = await service.resolve(userdataURIFromPaths([]));
284
		const sourceFile = joinPath(parent.resource, 'sourceFile');
285
		await service.writeFile(sourceFile, VSBuffer.fromString('This is source file'));
286

287
		const targetFile = joinPath(parent.resource, 'targetFile');
288
		await service.writeFile(targetFile, VSBuffer.fromString('This is target file'));
289

290
		try {
291
			await service.move(sourceFile, targetFile, false);
292
		} catch (error) {
293
			assert.deepStrictEqual((<FileOperationError>error).fileOperationResult, FileOperationResult.FILE_MOVE_CONFLICT);
294
			return;
295
		}
296

297
		assert.fail('This should fail with error');
298
	});
299

300
	test('rename folder to an existing folder without overwrite', async () => {
301
		const parent = await service.resolve(userdataURIFromPaths([]));
302
		const sourceFolder = joinPath(parent.resource, 'sourceFolder');
303
		await service.createFolder(sourceFolder);
304
		const targetFolder = joinPath(parent.resource, 'targetFolder');
305
		await service.createFolder(targetFolder);
306

307
		try {
308
			await service.move(sourceFolder, targetFolder, false);
309
		} catch (error) {
310
			assert.deepStrictEqual((<FileOperationError>error).fileOperationResult, FileOperationResult.FILE_MOVE_CONFLICT);
311
			return;
312
		}
313

314
		assert.fail('This should fail with cannot overwrite error');
315
	});
316

317
	test('rename file to a folder', async () => {
318
		const parent = await service.resolve(userdataURIFromPaths([]));
319
		const sourceFile = joinPath(parent.resource, 'sourceFile');
320
		await service.writeFile(sourceFile, VSBuffer.fromString('This is source file'));
321

322
		const targetFolder = joinPath(parent.resource, 'targetFolder');
323
		await service.createFolder(targetFolder);
324

325
		try {
326
			await service.move(sourceFile, targetFolder, false);
327
		} catch (error) {
328
			assert.deepStrictEqual((<FileOperationError>error).fileOperationResult, FileOperationResult.FILE_MOVE_CONFLICT);
329
			return;
330
		}
331

332
		assert.fail('This should fail with error');
333
	});
334

335
	test('rename folder to a file', async () => {
336
		const parent = await service.resolve(userdataURIFromPaths([]));
337
		const sourceFolder = joinPath(parent.resource, 'sourceFile');
338
		await service.createFolder(sourceFolder);
339

340
		const targetFile = joinPath(parent.resource, 'targetFile');
341
		await service.writeFile(targetFile, VSBuffer.fromString('This is target file'));
342

343
		try {
344
			await service.move(sourceFolder, targetFile, false);
345
		} catch (error) {
346
			assert.deepStrictEqual((<FileOperationError>error).fileOperationResult, FileOperationResult.FILE_MOVE_CONFLICT);
347
			return;
348
		}
349

350
		assert.fail('This should fail with error');
351
	});
352

353
	test('rename file', async () => {
354
		const parent = await service.resolve(userdataURIFromPaths([]));
355
		const sourceFile = joinPath(parent.resource, 'sourceFile');
356
		await service.writeFile(sourceFile, VSBuffer.fromString('This is source file'));
357

358
		const targetFile = joinPath(parent.resource, 'targetFile');
359
		await service.move(sourceFile, targetFile, false);
360

361
		const content = await service.readFile(targetFile);
362
		assert.strictEqual(await service.exists(sourceFile), false);
363
		assert.strictEqual(content.value.toString(), 'This is source file');
364
	});
365

366
	test('rename to an existing file with overwrite', async () => {
367
		const parent = await service.resolve(userdataURIFromPaths([]));
368
		const sourceFile = joinPath(parent.resource, 'sourceFile');
369
		const targetFile = joinPath(parent.resource, 'targetFile');
370

371
		await Promise.all([
372
			service.writeFile(sourceFile, VSBuffer.fromString('This is source file')),
373
			service.writeFile(targetFile, VSBuffer.fromString('This is target file'))
374
		]);
375

376
		await service.move(sourceFile, targetFile, true);
377

378
		const content = await service.readFile(targetFile);
379
		assert.strictEqual(await service.exists(sourceFile), false);
380
		assert.strictEqual(content.value.toString(), 'This is source file');
381
	});
382

383
	test('rename folder to a new folder', async () => {
384
		const parent = await service.resolve(userdataURIFromPaths([]));
385
		const sourceFolder = joinPath(parent.resource, 'sourceFolder');
386
		await service.createFolder(sourceFolder);
387

388
		const targetFolder = joinPath(parent.resource, 'targetFolder');
389
		await service.move(sourceFolder, targetFolder, false);
390

391
		assert.deepStrictEqual(await service.exists(sourceFolder), false);
392
		assert.deepStrictEqual(await service.exists(targetFolder), true);
393
	});
394

395
	test('rename folder to an existing folder', async () => {
396
		const parent = await service.resolve(userdataURIFromPaths([]));
397
		const sourceFolder = joinPath(parent.resource, 'sourceFolder');
398
		await service.createFolder(sourceFolder);
399
		const targetFolder = joinPath(parent.resource, 'targetFolder');
400
		await service.createFolder(targetFolder);
401

402
		await service.move(sourceFolder, targetFolder, true);
403

404
		assert.deepStrictEqual(await service.exists(sourceFolder), false);
405
		assert.deepStrictEqual(await service.exists(targetFolder), true);
406
	});
407

408
	test('rename a folder that has multiple files and folders', async () => {
409
		const parent = await service.resolve(userdataURIFromPaths([]));
410

411
		const sourceFolder = joinPath(parent.resource, 'sourceFolder');
412
		const sourceFile1 = joinPath(sourceFolder, 'folder1', 'file1');
413
		const sourceFile2 = joinPath(sourceFolder, 'folder2', 'file1');
414
		const sourceEmptyFolder = joinPath(sourceFolder, 'folder3');
415

416
		await Promise.all([
417
			service.writeFile(sourceFile1, VSBuffer.fromString('Source File 1')),
418
			service.writeFile(sourceFile2, VSBuffer.fromString('Source File 2')),
419
			service.createFolder(sourceEmptyFolder)
420
		]);
421

422
		const targetFolder = joinPath(parent.resource, 'targetFolder');
423
		const targetFile1 = joinPath(targetFolder, 'folder1', 'file1');
424
		const targetFile2 = joinPath(targetFolder, 'folder2', 'file1');
425
		const targetEmptyFolder = joinPath(targetFolder, 'folder3');
426

427
		await service.move(sourceFolder, targetFolder, false);
428

429
		assert.deepStrictEqual(await service.exists(sourceFolder), false);
430
		assert.deepStrictEqual(await service.exists(targetFolder), true);
431
		assert.strictEqual((await service.readFile(targetFile1)).value.toString(), 'Source File 1');
432
		assert.strictEqual((await service.readFile(targetFile2)).value.toString(), 'Source File 2');
433
		assert.deepStrictEqual(await service.exists(targetEmptyFolder), true);
434
	});
435

436
	test('rename a folder to another folder that has some files', async () => {
437
		const parent = await service.resolve(userdataURIFromPaths([]));
438

439
		const sourceFolder = joinPath(parent.resource, 'sourceFolder');
440
		const sourceFile1 = joinPath(sourceFolder, 'folder1', 'file1');
441

442
		const targetFolder = joinPath(parent.resource, 'targetFolder');
443
		const targetFile1 = joinPath(targetFolder, 'folder1', 'file1');
444
		const targetFile2 = joinPath(targetFolder, 'folder1', 'file2');
445
		const targetFile3 = joinPath(targetFolder, 'folder2', 'file1');
446

447
		await Promise.all([
448
			service.writeFile(sourceFile1, VSBuffer.fromString('Source File 1')),
449
			service.writeFile(targetFile2, VSBuffer.fromString('Target File 2')),
450
			service.writeFile(targetFile3, VSBuffer.fromString('Target File 3'))
451
		]);
452

453
		await service.move(sourceFolder, targetFolder, true);
454

455
		assert.deepStrictEqual(await service.exists(sourceFolder), false);
456
		assert.deepStrictEqual(await service.exists(targetFolder), true);
457
		assert.strictEqual((await service.readFile(targetFile1)).value.toString(), 'Source File 1');
458
		assert.strictEqual(await service.exists(targetFile2), false);
459
		assert.strictEqual(await service.exists(targetFile3), false);
460
	});
461

462
	test('deleteFile', async () => {
463
		await initFixtures();
464

465
		let event: FileOperationEvent;
466
		disposables.add(service.onDidRunOperation(e => event = e));
467

468
		const anotherResource = userdataURIFromPaths(['fixtures', 'service', 'deep', 'company.js']);
469
		const resource = userdataURIFromPaths(['fixtures', 'service', 'deep', 'conway.js']);
470
		const source = await service.resolve(resource);
471

472
		assert.strictEqual(await service.canDelete(source.resource, { useTrash: false }), true);
473
		await service.del(source.resource, { useTrash: false });
474

475
		assert.strictEqual(await service.exists(source.resource), false);
476
		assert.strictEqual(await service.exists(anotherResource), true);
477

478
		assert.ok(event!);
479
		assert.strictEqual(event!.resource.path, resource.path);
480
		assert.strictEqual(event!.operation, FileOperation.DELETE);
481

482
		{
483
			let error: Error | undefined = undefined;
484
			try {
485
				await service.del(source.resource, { useTrash: false });
486
			} catch (e) {
487
				error = e;
488
			}
489

490
			assert.ok(error);
491
			assert.strictEqual((<FileOperationError>error).fileOperationResult, FileOperationResult.FILE_NOT_FOUND);
492
		}
493
		await reload();
494
		{
495
			let error: Error | undefined = undefined;
496
			try {
497
				await service.del(source.resource, { useTrash: false });
498
			} catch (e) {
499
				error = e;
500
			}
501

502
			assert.ok(error);
503
			assert.strictEqual((<FileOperationError>error).fileOperationResult, FileOperationResult.FILE_NOT_FOUND);
504
		}
505
	});
506

507
	test('deleteFolder (recursive)', async () => {
508
		await initFixtures();
509
		let event: FileOperationEvent;
510
		disposables.add(service.onDidRunOperation(e => event = e));
511

512
		const resource = userdataURIFromPaths(['fixtures', 'service', 'deep']);
513
		const subResource1 = userdataURIFromPaths(['fixtures', 'service', 'deep', 'company.js']);
514
		const subResource2 = userdataURIFromPaths(['fixtures', 'service', 'deep', 'conway.js']);
515
		assert.strictEqual(await service.exists(subResource1), true);
516
		assert.strictEqual(await service.exists(subResource2), true);
517

518
		const source = await service.resolve(resource);
519

520
		assert.strictEqual(await service.canDelete(source.resource, { recursive: true, useTrash: false }), true);
521
		await service.del(source.resource, { recursive: true, useTrash: false });
522

523
		assert.strictEqual(await service.exists(source.resource), false);
524
		assert.strictEqual(await service.exists(subResource1), false);
525
		assert.strictEqual(await service.exists(subResource2), false);
526
		assert.ok(event!);
527
		assert.strictEqual(event!.resource.fsPath, resource.fsPath);
528
		assert.strictEqual(event!.operation, FileOperation.DELETE);
529
	});
530

531
	test('deleteFolder (non recursive)', async () => {
532
		await initFixtures();
533
		const resource = userdataURIFromPaths(['fixtures', 'service', 'deep']);
534
		const source = await service.resolve(resource);
535

536
		assert.ok((await service.canDelete(source.resource)) instanceof Error);
537

538
		let error;
539
		try {
540
			await service.del(source.resource);
541
		} catch (e) {
542
			error = e;
543
		}
544
		assert.ok(error);
545
	});
546

547
	test('delete empty folder', async () => {
548
		const parent = await service.resolve(userdataURIFromPaths([]));
549
		const folder = joinPath(parent.resource, 'folder');
550
		await service.createFolder(folder);
551

552
		await service.del(folder);
553

554
		assert.deepStrictEqual(await service.exists(folder), false);
555
	});
556

557
	test('delete empty folder with reccursive', async () => {
558
		const parent = await service.resolve(userdataURIFromPaths([]));
559
		const folder = joinPath(parent.resource, 'folder');
560
		await service.createFolder(folder);
561

562
		await service.del(folder, { recursive: true });
563

564
		assert.deepStrictEqual(await service.exists(folder), false);
565
	});
566

567
	test('deleteFolder with folders and files (recursive)', async () => {
568
		const parent = await service.resolve(userdataURIFromPaths([]));
569

570
		const targetFolder = joinPath(parent.resource, 'targetFolder');
571
		const file1 = joinPath(targetFolder, 'folder1', 'file1');
572
		await service.createFile(file1);
573
		const file2 = joinPath(targetFolder, 'folder2', 'file1');
574
		await service.createFile(file2);
575
		const emptyFolder = joinPath(targetFolder, 'folder3');
576
		await service.createFolder(emptyFolder);
577

578
		await service.del(targetFolder, { recursive: true });
579

580
		assert.deepStrictEqual(await service.exists(targetFolder), false);
581
		assert.deepStrictEqual(await service.exists(joinPath(targetFolder, 'folder1')), false);
582
		assert.deepStrictEqual(await service.exists(joinPath(targetFolder, 'folder2')), false);
583
		assert.deepStrictEqual(await service.exists(file1), false);
584
		assert.deepStrictEqual(await service.exists(file2), false);
585
		assert.deepStrictEqual(await service.exists(emptyFolder), false);
586
	});
587
});
588

589
Product

Resources

Company
