Initial scaffolding for indexeddb fsp testing. Ref #108566

src/vs/platform/files/browser/indexedDBFileSystemProvider.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { URI } from 'vs/base/common/uri';
-import { IFileSystemProvider, IFileSystemProviderWithFileReadWriteCapability, FileSystemProviderCapabilities, IFileChange, IWatchOptions, IStat, FileOverwriteOptions, FileType, FileDeleteOptions, FileWriteOptions, FileChangeType, createFileSystemProviderError, FileSystemProviderErrorCode } from 'vs/platform/files/common/files';
+import { IFileSystemProviderWithFileReadWriteCapability, FileSystemProviderCapabilities, IFileChange, IWatchOptions, IStat, FileOverwriteOptions, FileType, FileDeleteOptions, FileWriteOptions, FileChangeType, createFileSystemProviderError, FileSystemProviderErrorCode } from 'vs/platform/files/common/files';
 import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
 import { Event, Emitter } from 'vs/base/common/event';
 import { VSBuffer } from 'vs/base/common/buffer';
@@ -24,8 +24,8 @@ export class IndexedDB {
 		this.indexedDBPromise = this.openIndexedDB(INDEXEDDB_VSCODE_DB, 2, [INDEXEDDB_USERDATA_OBJECT_STORE, INDEXEDDB_LOGS_OBJECT_STORE]);
 	}
 
-	async createFileSystemProvider(scheme: string, store: string): Promise<IFileSystemProvider | null> {
-		let fsp: IFileSystemProvider | null = null;
+	async createFileSystemProvider(scheme: string, store: string): Promise<IIndexedDBFileSystemProvider | null> {
+		let fsp: IIndexedDBFileSystemProvider | null = null;
 		const indexedDB = await this.indexedDBPromise;
 		if (indexedDB) {
 			if (indexedDB.objectStoreNames.contains(store)) {
@@ -68,7 +68,8 @@ export class IndexedDB {
 
 }
 
-class IndexedDBFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+export interface IIndexedDBFileSystemProvider extends Disposable, IFileSystemProviderWithFileReadWriteCapability { }
+class IndexedDBFileSystemProvider extends Disposable implements IIndexedDBFileSystemProvider {
 
 	readonly capabilities: FileSystemProviderCapabilities =
 		FileSystemProviderCapabilities.FileReadWrite

src/vs/platform/files/test/browser/indexedDBFileService.test.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { FileService } from 'vs/platform/files/common/fileService';
+import { Schemas } from 'vs/base/common/network';
+import { join } from 'vs/base/common/path';
+import { URI } from 'vs/base/common/uri';
+import { FileOperation, FileOperationEvent } from 'vs/platform/files/common/files';
+import { NullLogService } from 'vs/platform/log/common/log';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { IIndexedDBFileSystemProvider, IndexedDB, INDEXEDDB_LOGS_OBJECT_STORE, INDEXEDDB_USERDATA_OBJECT_STORE } from 'vs/platform/files/browser/indexedDBFileSystemProvider';
+import { assertIsDefined } from 'vs/base/common/types';
+
+suite('IndexedDB File Service', function () {
+
+	const logSchema = 'logs';
+
+	let service: FileService;
+	let logFileProvider: IIndexedDBFileSystemProvider;
+	let userdataFileProvider: IIndexedDBFileSystemProvider;
+	const testDir = '/';
+
+	const makeLogfileURI = (path: string) => URI.from({ scheme: logSchema, path });
+	const makeUserdataURI = (path: string) => URI.from({ scheme: Schemas.userData, path });
+
+	const disposables = new DisposableStore();
+
+	setup(async () => {
+		const logService = new NullLogService();
+
+		service = new FileService(logService);
+		disposables.add(service);
+
+		logFileProvider = assertIsDefined(await new IndexedDB().createFileSystemProvider(Schemas.file, INDEXEDDB_LOGS_OBJECT_STORE));
+		disposables.add(service.registerProvider(logSchema, logFileProvider));
+		disposables.add(logFileProvider);
+
+		userdataFileProvider = assertIsDefined(await new IndexedDB().createFileSystemProvider(logSchema, INDEXEDDB_USERDATA_OBJECT_STORE));
+		disposables.add(service.registerProvider(Schemas.userData, userdataFileProvider));
+		disposables.add(userdataFileProvider);
+	});
+
+	teardown(async () => {
+		disposables.clear();
+
+		await logFileProvider.delete(makeLogfileURI(testDir), { recursive: true, useTrash: false });
+		await userdataFileProvider.delete(makeUserdataURI(testDir), { recursive: true, useTrash: false });
+	});
+
+	test('createFolder', async () => {
+		let event: FileOperationEvent | undefined;
+		disposables.add(service.onDidRunOperation(e => event = e));
+
+		const parent = await service.resolve(makeUserdataURI(testDir));
+
+		const newFolderResource = makeUserdataURI(join(parent.resource.fsPath, 'newFolder'));
+
+		assert.equal((await userdataFileProvider.readdir(parent.resource)).length, 0);
+		const newFolder = await service.createFolder(newFolderResource);
+		assert.equal(newFolder.name, 'newFolder');
+		// Invalid.. dirs dont exist in our IDBFSB.
+		// assert.equal((await userdataFileProvider.readdir(parent.resource)).length, 1);
+
+		assert.ok(event);
+		assert.equal(event!.resource.fsPath, newFolderResource.fsPath);
+		assert.equal(event!.operation, FileOperation.CREATE);
+		assert.equal(event!.target!.resource.fsPath, newFolderResource.fsPath);
+		assert.equal(event!.target!.isDirectory, true);
+	});
+});