Fix #101339

src/vs/platform/configuration/test/node/configurationService.test.ts

@@ -4,179 +4,142 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import * as os from 'os';
-import * as path from 'vs/base/common/path';
-import * as fs from 'fs';
 
 import { Registry } from 'vs/platform/registry/common/platform';
 import { ConfigurationService } from 'vs/platform/configuration/common/configurationService';
-import * as uuid from 'vs/base/common/uuid';
 import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry';
-import { testFile } from 'vs/base/test/node/utils';
+import { testFile, ITestFileResult } from 'vs/base/test/node/utils';
 import { URI } from 'vs/base/common/uri';
 import { ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
 import { Event } from 'vs/base/common/event';
 import { NullLogService } from 'vs/platform/log/common/log';
 import { FileService } from 'vs/platform/files/common/fileService';
-import { IDisposable } from 'vs/base/common/lifecycle';
-import { DiskFileSystemProvider } from 'vs/platform/files/node/diskFileSystemProvider';
+import { DisposableStore } from 'vs/base/common/lifecycle';
 import { Schemas } from 'vs/base/common/network';
 import { IFileService } from 'vs/platform/files/common/files';
 import { VSBuffer } from 'vs/base/common/buffer';
+import { InMemoryFileSystemProvider } from 'vs/platform/files/common/inMemoryFilesystemProvider';
 
 suite('ConfigurationService - Node', () => {
 
 	let fileService: IFileService;
-	const disposables: IDisposable[] = [];
-
-	setup(() => {
-		const logService = new NullLogService();
-		fileService = new FileService(logService);
-		disposables.push(fileService);
-		const diskFileSystemProvider = new DiskFileSystemProvider(logService);
-		disposables.push(diskFileSystemProvider);
+	let testFileResult: ITestFileResult;
+	let settingsResource: URI;
+	const disposables: DisposableStore = new DisposableStore();
+
+	setup(async () => {
+		fileService = new FileService(new NullLogService());
+		disposables.add(fileService);
+		const diskFileSystemProvider = new InMemoryFileSystemProvider();
+		disposables.add(diskFileSystemProvider);
 		fileService.registerProvider(Schemas.file, diskFileSystemProvider);
+		testFileResult = await testFile('config', 'config.json');
+		settingsResource = URI.file(testFileResult.testFile);
 	});
 
-	test('simple', async () => {
-		const res = await testFile('config', 'config.json');
-		fs.writeFileSync(res.testFile, '{ "foo": "bar" }');
+	teardown(async () => {
+		disposables.clear();
+		await testFileResult.cleanUp();
+	});
 
-		const service = new ConfigurationService(URI.file(res.testFile), fileService);
-		await service.initialize();
-		const config = service.getValue<{
+	test('simple', async () => {
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "foo": "bar" }'));
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		await testObject.initialize();
+		const config = testObject.getValue<{
 			foo: string;
 		}>();
 
 		assert.ok(config);
 		assert.equal(config.foo, 'bar');
-		service.dispose();
-
-		return res.cleanUp();
 	});
 
 	test('config gets flattened', async () => {
-		const res = await testFile('config', 'config.json');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "testworkbench.editor.tabs": true }'));
 
-		fs.writeFileSync(res.testFile, '{ "testworkbench.editor.tabs": true }');
-
-		const service = new ConfigurationService(URI.file(res.testFile), fileService);
-		await service.initialize();
-		const config = service.getValue<{
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		await testObject.initialize();
+		const config = testObject.getValue<{
 			testworkbench: {
 				editor: {
 					tabs: boolean;
 				};
 			};
 		}>();
+
 		assert.ok(config);
 		assert.ok(config.testworkbench);
 		assert.ok(config.testworkbench.editor);
 		assert.equal(config.testworkbench.editor.tabs, true);
-
-		service.dispose();
-		return res.cleanUp();
 	});
 
 	test('error case does not explode', async () => {
-		const res = await testFile('config', 'config.json');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString(',,,,'));
 
-		fs.writeFileSync(res.testFile, ',,,,');
-
-		const service = new ConfigurationService(URI.file(res.testFile), fileService);
-		await service.initialize();
-		const config = service.getValue<{
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		await testObject.initialize();
+		const config = testObject.getValue<{
 			foo: string;
 		}>();
-		assert.ok(config);
 
-		service.dispose();
-		return res.cleanUp();
+		assert.ok(config);
 	});
 
 	test('missing file does not explode', async () => {
-		const id = uuid.generateUuid();
-		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
-		const newDir = path.join(parentDir, 'config', id);
-		const testFile = path.join(newDir, 'config.json');
+		const testObject = disposables.add(new ConfigurationService(URI.file('__testFile'), fileService));
+		await testObject.initialize();
 
-		const service = new ConfigurationService(URI.file(testFile), fileService);
-		await service.initialize();
+		const config = testObject.getValue<{ foo: string }>();
 
-		const config = service.getValue<{ foo: string }>();
 		assert.ok(config);
-
-		service.dispose();
 	});
 
 	test('trigger configuration change event when file does not exist', async () => {
-		const res = await testFile('config', 'config.json');
-		const settingsFile = URI.file(res.testFile);
-		const service = new ConfigurationService(settingsFile, fileService);
-		await service.initialize();
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		await testObject.initialize();
 		return new Promise(async (c, e) => {
-			const disposable = Event.filter(service.onDidChangeConfiguration, e => e.source === ConfigurationTarget.USER)(async (e) => {
-				disposable.dispose();
-				assert.equal(service.getValue('foo'), 'bar');
-				service.dispose();
-				await res.cleanUp();
+			disposables.add(Event.filter(testObject.onDidChangeConfiguration, e => e.source === ConfigurationTarget.USER)(() => {
+				assert.equal(testObject.getValue('foo'), 'bar');
 				c();
-			});
-			await fileService.writeFile(settingsFile, VSBuffer.fromString('{ "foo": "bar" }'));
+			}));
+			await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "foo": "bar" }'));
 		});
 
 	});
 
 	test('trigger configuration change event when file exists', async () => {
-		const res = await testFile('config', 'config.json');
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "foo": "bar" }'));
+		await testObject.initialize();
 
-		const service = new ConfigurationService(URI.file(res.testFile), fileService);
-		fs.writeFileSync(res.testFile, '{ "foo": "bar" }');
-		await service.initialize();
 		return new Promise((c, e) => {
-			const disposable = Event.filter(service.onDidChangeConfiguration, e => e.source === ConfigurationTarget.USER)(async (e) => {
-				disposable.dispose();
-				assert.equal(service.getValue('foo'), 'barz');
-				service.dispose();
-				await res.cleanUp();
+			disposables.add(Event.filter(testObject.onDidChangeConfiguration, e => e.source === ConfigurationTarget.USER)(async (e) => {
+				assert.equal(testObject.getValue('foo'), 'barz');
 				c();
-			});
-			fs.writeFileSync(res.testFile, '{ "foo": "barz" }');
+			}));
+			fileService.writeFile(settingsResource, VSBuffer.fromString('{ "foo": "barz" }'));
 		});
-
 	});
 
 	test('reloadConfiguration', async () => {
-		const res = await testFile('config', 'config.json');
-
-		fs.writeFileSync(res.testFile, '{ "foo": "bar" }');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "foo": "bar" }'));
 
-		const service = new ConfigurationService(URI.file(res.testFile), fileService);
-		await service.initialize();
-		let config = service.getValue<{
-			foo: string;
-		}>();
-		assert.ok(config);
-		assert.equal(config.foo, 'bar');
-		fs.writeFileSync(res.testFile, '{ "foo": "changed" }');
-
-		// still outdated
-		config = service.getValue<{
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		await testObject.initialize();
+		let config = testObject.getValue<{
 			foo: string;
 		}>();
 		assert.ok(config);
 		assert.equal(config.foo, 'bar');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "foo": "changed" }'));
 
 		// force a reload to get latest
-		await service.reloadConfiguration();
-		config = service.getValue<{
+		await testObject.reloadConfiguration();
+		config = testObject.getValue<{
 			foo: string;
 		}>();
 		assert.ok(config);
 		assert.equal(config.foo, 'changed');
-
-		service.dispose();
-		return res.cleanUp();
 	});
 
 	test('model defaults', async () => {
@@ -200,33 +163,27 @@ suite('ConfigurationService - Node', () => {
 			}
 		});
 
-		let serviceWithoutFile = new ConfigurationService(URI.file('__testFile'), fileService);
-		await serviceWithoutFile.initialize();
-		let setting = serviceWithoutFile.getValue<ITestSetting>();
+		let testObject = disposables.add(new ConfigurationService(URI.file('__testFile'), fileService));
+		await testObject.initialize();
+		let setting = testObject.getValue<ITestSetting>();
 
 		assert.ok(setting);
 		assert.equal(setting.configuration.service.testSetting, 'isSet');
 
-		return testFile('config', 'config.json').then(async res => {
-			fs.writeFileSync(res.testFile, '{ "testworkbench.editor.tabs": true }');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "testworkbench.editor.tabs": true }'));
+		testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
 
-			const service = new ConfigurationService(URI.file(res.testFile), fileService);
+		setting = testObject.getValue<ITestSetting>();
 
-			let setting = service.getValue<ITestSetting>();
-
-			assert.ok(setting);
-			assert.equal(setting.configuration.service.testSetting, 'isSet');
+		assert.ok(setting);
+		assert.equal(setting.configuration.service.testSetting, 'isSet');
 
-			fs.writeFileSync(res.testFile, '{ "configuration.service.testSetting": "isChanged" }');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "configuration.service.testSetting": "isChanged" }'));
 
-			await service.reloadConfiguration();
-			let setting_1 = service.getValue<ITestSetting>();
-			assert.ok(setting_1);
-			assert.equal(setting_1.configuration.service.testSetting, 'isChanged');
-			service.dispose();
-			serviceWithoutFile.dispose();
-			return res.cleanUp();
-		});
+		await testObject.reloadConfiguration();
+		setting = testObject.getValue<ITestSetting>();
+		assert.ok(setting);
+		assert.equal(setting.configuration.service.testSetting, 'isChanged');
 	});
 
 	test('lookup', async () => {
@@ -242,30 +199,27 @@ suite('ConfigurationService - Node', () => {
 			}
 		});
 
-		const r = await testFile('config', 'config.json');
-		const service = new ConfigurationService(URI.file(r.testFile), fileService);
-		service.initialize();
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		testObject.initialize();
 
-		let res = service.inspect('something.missing');
+		let res = testObject.inspect('something.missing');
 		assert.strictEqual(res.value, undefined);
 		assert.strictEqual(res.defaultValue, undefined);
 		assert.strictEqual(res.userValue, undefined);
 
-		res = service.inspect('lookup.service.testSetting');
+		res = testObject.inspect('lookup.service.testSetting');
 		assert.strictEqual(res.defaultValue, 'isSet');
 		assert.strictEqual(res.value, 'isSet');
 		assert.strictEqual(res.userValue, undefined);
 
-		fs.writeFileSync(r.testFile, '{ "lookup.service.testSetting": "bar" }');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "lookup.service.testSetting": "bar" }'));
 
-		await service.reloadConfiguration();
-		res = service.inspect('lookup.service.testSetting');
+		await testObject.reloadConfiguration();
+		res = testObject.inspect('lookup.service.testSetting');
 		assert.strictEqual(res.defaultValue, 'isSet');
 		assert.strictEqual(res.userValue, 'bar');
 		assert.strictEqual(res.value, 'bar');
 
-		service.dispose();
-		return r.cleanUp();
 	});
 
 	test('lookup with null', async () => {
@@ -280,25 +234,21 @@ suite('ConfigurationService - Node', () => {
 			}
 		});
 
-		const r = await testFile('config', 'config.json');
-		const service = new ConfigurationService(URI.file(r.testFile), fileService);
-		service.initialize();
+		const testObject = disposables.add(new ConfigurationService(settingsResource, fileService));
+		testObject.initialize();
 
-		let res = service.inspect('lookup.service.testNullSetting');
+		let res = testObject.inspect('lookup.service.testNullSetting');
 		assert.strictEqual(res.defaultValue, null);
 		assert.strictEqual(res.value, null);
 		assert.strictEqual(res.userValue, undefined);
 
-		fs.writeFileSync(r.testFile, '{ "lookup.service.testNullSetting": null }');
+		await fileService.writeFile(settingsResource, VSBuffer.fromString('{ "lookup.service.testNullSetting": null }'));
 
-		await service.reloadConfiguration();
+		await testObject.reloadConfiguration();
 
-		res = service.inspect('lookup.service.testNullSetting');
+		res = testObject.inspect('lookup.service.testNullSetting');
 		assert.strictEqual(res.defaultValue, null);
 		assert.strictEqual(res.value, null);
 		assert.strictEqual(res.userValue, null);
-
-		service.dispose();
-		return r.cleanUp();
 	});
 });