file working copy - first cut tests

Author: bpasero

src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.ts

@@ -22,7 +22,7 @@ import { ILogService } from 'vs/platform/log/common/log';
  * operations that are working copy related, such as save/revert, backup
  * and resolving.
  */
-export interface IFileWorkingCopyManager<T extends IFileWorkingCopyModel> {
+export interface IFileWorkingCopyManager<T extends IFileWorkingCopyModel> extends IDisposable {
 
 	/**
 	 * An event for when a file working copy was created.
@@ -334,7 +334,7 @@ export class FileWorkingCopyManager<T extends IFileWorkingCopyModel> extends Dis
 		this.mapResourceToWorkingCopyListeners.set(workingCopy.resource, workingCopyListeners);
 	}
 
-	protected add(resource: URI, workingCopy: IFileWorkingCopy<T>): void {
+	private add(resource: URI, workingCopy: IFileWorkingCopy<T>): void {
 		const knownWorkingCopy = this.mapResourceToWorkingCopy.get(resource);
 		if (knownWorkingCopy === workingCopy) {
 			return; // already cached
@@ -351,7 +351,7 @@ export class FileWorkingCopyManager<T extends IFileWorkingCopyModel> extends Dis
 		this.mapResourceToDisposeListener.set(resource, workingCopy.onWillDispose(() => this.remove(resource)));
 	}
 
-	protected remove(resource: URI): void {
+	private remove(resource: URI): void {
 		this.mapResourceToWorkingCopy.delete(resource);
 
 		const disposeListener = this.mapResourceToDisposeListener.get(resource);
@@ -367,7 +367,7 @@ export class FileWorkingCopyManager<T extends IFileWorkingCopyModel> extends Dis
 		}
 	}
 
-	clear(): void {
+	private clear(): void {
 
 		// working copy caches
 		this.mapResourceToWorkingCopy.clear();

src/vs/workbench/services/workingCopy/test/browser/fileWorkingCopy.test.ts

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter } from 'vs/base/common/event';
+import { URI } from 'vs/base/common/uri';
+import { IFileWorkingCopyModel, IFileWorkingCopyModelContentChangedEvent, IFileWorkingCopyModelFactory } from 'vs/workbench/services/workingCopy/common/fileWorkingCopy';
+import { newWriteableBufferStream, streamToBuffer, VSBuffer, VSBufferReadableStream } from 'vs/base/common/buffer';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { Disposable } from 'vs/base/common/lifecycle';
+
+export class TestFileWorkingCopyModel extends Disposable implements IFileWorkingCopyModel {
+
+	private readonly _onDidChangeContent = this._register(new Emitter<IFileWorkingCopyModelContentChangedEvent>());
+	readonly onDidChangeContent = this._onDidChangeContent.event;
+
+	private readonly _onWillDispose = this._register(new Emitter<void>());
+	readonly onWillDispose = this._onWillDispose.event;
+
+	constructor(readonly resource: URI, public contents: string) {
+		super();
+	}
+
+	fireContentChangeEvent(event: IFileWorkingCopyModelContentChangedEvent): void {
+		this._onDidChangeContent.fire(event);
+	}
+
+	updateContents(newContents: string): void {
+		this.contents = newContents;
+		this.versionId++;
+
+		this._onDidChangeContent.fire({ isRedoing: false, isUndoing: false });
+	}
+
+	async snapshot(token: CancellationToken): Promise<VSBufferReadableStream> {
+		const stream = newWriteableBufferStream();
+		stream.end(VSBuffer.fromString(this.contents));
+
+		return stream;
+	}
+
+	async update(contents: VSBufferReadableStream, token: CancellationToken): Promise<void> {
+		this.contents = (await streamToBuffer(contents)).toString();
+	}
+
+	versionId = 0;
+
+	getAlternativeVersionId(): number {
+		return this.versionId;
+	}
+
+	pushStackElement(): void { }
+
+	dispose(): void {
+		this._onWillDispose.fire();
+
+		super.dispose();
+	}
+}
+
+export class TestFileWorkingCopyModelFactory implements IFileWorkingCopyModelFactory<TestFileWorkingCopyModel> {
+
+	async createModel(resource: URI, contents: VSBufferReadableStream, token: CancellationToken): Promise<TestFileWorkingCopyModel> {
+		return new TestFileWorkingCopyModel(resource, (await streamToBuffer(contents)).toString());
+	}
+}
+
+suite('FileWorkingCopy', () => {
+
+
+});

src/vs/workbench/services/workingCopy/test/browser/fileWorkingCopyManager.test.ts

@@ -0,0 +1,211 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { URI } from 'vs/base/common/uri';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { workbenchInstantiationService, TestServiceAccessor } from 'vs/workbench/test/browser/workbenchTestServices';
+import { FileWorkingCopyManager, IFileWorkingCopyManager } from 'vs/workbench/services/workingCopy/common/fileWorkingCopyManager';
+import { IFileWorkingCopy, IFileWorkingCopyModel } from 'vs/workbench/services/workingCopy/common/fileWorkingCopy';
+import { bufferToStream, VSBuffer } from 'vs/base/common/buffer';
+import { FileChangesEvent, FileChangeType } from 'vs/platform/files/common/files';
+import { timeout } from 'vs/base/common/async';
+import { TestFileWorkingCopyModel, TestFileWorkingCopyModelFactory } from 'vs/workbench/services/workingCopy/test/browser/fileWorkingCopy.test';
+
+suite('FileWorkingCopyManager', () => {
+
+	let instantiationService: IInstantiationService;
+	let accessor: TestServiceAccessor;
+
+	let manager: IFileWorkingCopyManager<TestFileWorkingCopyModel>;
+
+	setup(() => {
+		instantiationService = workbenchInstantiationService();
+		accessor = instantiationService.createInstance(TestServiceAccessor);
+
+		const factory = new TestFileWorkingCopyModelFactory();
+		manager = new FileWorkingCopyManager<TestFileWorkingCopyModel>(factory, accessor.fileService, accessor.lifecycleService, accessor.labelService, instantiationService, accessor.logService);
+	});
+
+	teardown(() => {
+		manager.dispose();
+	});
+
+	test('resolve', async () => {
+		const resource = URI.file('/test.html');
+
+		const events: IFileWorkingCopy<IFileWorkingCopyModel>[] = [];
+		const listener = manager.onDidCreate(workingCopy => {
+			events.push(workingCopy);
+		});
+
+		const resolvePromise = manager.resolve(resource);
+		assert.ok(manager.get(resource)); // working copy known even before resolved()
+
+		const workingCopy1 = await resolvePromise;
+		assert.ok(workingCopy1);
+		assert.ok(workingCopy1.model);
+		assert.strictEqual(manager.get(resource), workingCopy1);
+
+		const workingCopy2 = await manager.resolve(resource);
+		assert.strictEqual(workingCopy2, workingCopy1);
+		workingCopy1.dispose();
+
+		const workingCopy3 = await manager.resolve(resource);
+		assert.notStrictEqual(workingCopy3, workingCopy2);
+		assert.strictEqual(manager.get(resource), workingCopy3);
+		workingCopy3.dispose();
+
+		assert.strictEqual(events.length, 2);
+		assert.strictEqual(events[0].resource.toString(), workingCopy1.resource.toString());
+		assert.strictEqual(events[1].resource.toString(), workingCopy2.resource.toString());
+
+		listener.dispose();
+
+		workingCopy1.dispose();
+		workingCopy2.dispose();
+		workingCopy3.dispose();
+	});
+
+	test('resolve with initial contents', async () => {
+		const resource = URI.file('/test.html');
+
+		const workingCopy = await manager.resolve(resource, { contents: bufferToStream(VSBuffer.fromString('Hello World')) });
+		assert.strictEqual(workingCopy.model?.contents, 'Hello World');
+		assert.strictEqual(workingCopy.isDirty(), true);
+
+		await manager.resolve(resource, { contents: bufferToStream(VSBuffer.fromString('More Changes')) });
+		assert.strictEqual(workingCopy.model?.contents, 'More Changes');
+		assert.strictEqual(workingCopy.isDirty(), true);
+
+		workingCopy.dispose();
+	});
+
+	test('multiple resolves execute in sequence', async () => {
+		const resource = URI.file('/test.html');
+
+		const firstPromise = manager.resolve(resource);
+		const secondPromise = manager.resolve(resource, { contents: bufferToStream(VSBuffer.fromString('Hello World')) });
+		const thirdPromise = manager.resolve(resource, { contents: bufferToStream(VSBuffer.fromString('More Changes')) });
+
+		await firstPromise;
+		await secondPromise;
+		const workingCopy = await thirdPromise;
+
+		assert.strictEqual(workingCopy.model?.contents, 'More Changes');
+		assert.strictEqual(workingCopy.isDirty(), true);
+
+		workingCopy.dispose();
+	});
+
+	test('removed from cache when working copy or model gets disposed', async () => {
+		const resource = URI.file('/test.html');
+
+		let workingCopy = await manager.resolve(resource, { contents: bufferToStream(VSBuffer.fromString('Hello World')) });
+
+		assert.strictEqual(manager.get(URI.file('/test.html')), workingCopy);
+
+		workingCopy.dispose();
+		assert(!manager.get(URI.file('/test.html')));
+
+		workingCopy = await manager.resolve(resource, { contents: bufferToStream(VSBuffer.fromString('Hello World')) });
+
+		assert.strictEqual(manager.get(URI.file('/test.html')), workingCopy);
+
+		workingCopy.model?.dispose();
+		assert(!manager.get(URI.file('/test.html')));
+	});
+
+	test('events', async () => {
+		const resource1 = URI.file('/path/index.txt');
+		const resource2 = URI.file('/path/other.txt');
+
+		let loadedCounter = 0;
+		let gotDirtyCounter = 0;
+		let gotNonDirtyCounter = 0;
+		let revertedCounter = 0;
+		let savedCounter = 0;
+
+		manager.onDidResolve(workingCopy => {
+			if (workingCopy.resource.toString() === resource1.toString()) {
+				loadedCounter++;
+			}
+		});
+
+		manager.onDidChangeDirty(workingCopy => {
+			if (workingCopy.resource.toString() === resource1.toString()) {
+				if (workingCopy.isDirty()) {
+					gotDirtyCounter++;
+				} else {
+					gotNonDirtyCounter++;
+				}
+			}
+		});
+
+		manager.onDidRevert(workingCopy => {
+			if (workingCopy.resource.toString() === resource1.toString()) {
+				revertedCounter++;
+			}
+		});
+
+		manager.onDidSave(({ workingCopy }) => {
+			if (workingCopy.resource.toString() === resource1.toString()) {
+				savedCounter++;
+			}
+		});
+
+		const workingCopy1 = await manager.resolve(resource1);
+		assert.strictEqual(loadedCounter, 1);
+
+		accessor.fileService.fireFileChanges(new FileChangesEvent([{ resource: resource1, type: FileChangeType.DELETED }], false));
+		accessor.fileService.fireFileChanges(new FileChangesEvent([{ resource: resource1, type: FileChangeType.ADDED }], false));
+
+		const workingCopy2 = await manager.resolve(resource2);
+		assert.strictEqual(loadedCounter, 2);
+
+		workingCopy1.model?.updateContents('changed');
+
+		await workingCopy1.revert();
+		workingCopy1.model?.updateContents('changed again');
+
+		await workingCopy1.save();
+		workingCopy1.dispose();
+		workingCopy2.dispose();
+
+		await workingCopy1.revert();
+		assert.strictEqual(gotDirtyCounter, 2);
+		assert.strictEqual(gotNonDirtyCounter, 2);
+		assert.strictEqual(revertedCounter, 1);
+		assert.strictEqual(savedCounter, 1);
+
+		workingCopy1.dispose();
+		workingCopy2.dispose();
+	});
+
+	test('canDispose with dirty model', async function () {
+		const resource = URI.file('/path/index_something.txt');
+
+		const workingCopy = await manager.resolve(resource);
+		workingCopy.model?.updateContents('make dirty');
+
+		let canDisposePromise = manager.canDispose(workingCopy);
+		assert.ok(canDisposePromise instanceof Promise);
+
+		let canDispose = false;
+		(async () => {
+			canDispose = await canDisposePromise;
+		})();
+
+		assert.strictEqual(canDispose, false);
+		workingCopy.revert({ soft: true });
+
+		await timeout(0);
+
+		assert.strictEqual(canDispose, true);
+
+		let canDispose2 = manager.canDispose(workingCopy);
+		assert.strictEqual(canDispose2, true);
+	});
+});

src/vs/workbench/test/browser/workbenchTestServices.ts

@@ -256,7 +256,9 @@ export class TestServiceAccessor {
 		@IConfigurationService public testConfigurationService: TestConfigurationService,
 		@IBackupFileService public backupFileService: TestBackupFileService,
 		@IHostService public hostService: TestHostService,
-		@IQuickInputService public quickInputService: IQuickInputService
+		@IQuickInputService public quickInputService: IQuickInputService,
+		@ILabelService public labelService: ILabelService,
+		@ILogService public logService: ILogService
 	) { }
 }