ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-05 01:25:38 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge VS Code 1.23.1 (#1520)

Browse Source
This commit is contained in:
Matt Irvine
2018-06-05 11:24:51 -07:00
committed by GitHub
parent e3baf5c443
commit 0c58f09e59
3651 changed files with 74249 additions and 48599 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/vs/platform/configuration/common/configuration.ts
View File

@@ -7,12 +7,12 @@ import { TPromise } from 'vs/base/common/winjs.base';
import * as objects from 'vs/base/common/objects';
import * as types from 'vs/base/common/types';
import URI from 'vs/base/common/uri';
import Event from 'vs/base/common/event';
import { Event } from 'vs/base/common/event';
import { Registry } from 'vs/platform/registry/common/platform';
import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IConfigurationRegistry, Extensions, OVERRIDE_PROPERTY_PATTERN } from 'vs/platform/configuration/common/configurationRegistry';
import { StrictResourceMap } from 'vs/base/common/map';
import { ResourceMap } from 'vs/base/common/map';
export const IConfigurationService = createDecorator<IConfigurationService>('configurationService');
@@ -47,7 +47,7 @@ export interface IConfigurationChangeEvent {
// Following data is used for Extension host configuration event
changedConfiguration: IConfigurationModel;
changedConfigurationByResource: StrictResourceMap<IConfigurationModel>;
changedConfigurationByResource: ResourceMap<IConfigurationModel>;
}
export interface IConfigurationService {
@@ -112,6 +112,7 @@ export interface IConfigurationData {
user: IConfigurationModel;
workspace: IConfigurationModel;
folders: { [folder: string]: IConfigurationModel };
isComplete: boolean;
}
export function compare(from: IConfigurationModel, to: IConfigurationModel): { added: string[], removed: string[], updated: string[] } {

45
src/vs/platform/configuration/common/configurationModels.ts
View File

@@ -5,7 +5,7 @@
'use strict';
import * as json from 'vs/base/common/json';
import { StrictResourceMap } from 'vs/base/common/map';
import { ResourceMap } from 'vs/base/common/map';
import * as arrays from 'vs/base/common/arrays';
import * as types from 'vs/base/common/types';
import * as objects from 'vs/base/common/objects';
@@ -85,7 +85,7 @@ export class ConfigurationModel implements IConfigurationModel {
if (override) {
this.mergeContents(override.contents, otherOverride.contents);
} else {
overrides.push(otherOverride);
overrides.push(objects.deepClone(otherOverride));
}
}
for (const key of other.keys) {
@@ -279,15 +279,16 @@ export class ConfigurationModelParser {
export class Configuration {
private _workspaceConsolidatedConfiguration: ConfigurationModel = null;
private _foldersConsolidatedConfigurations: StrictResourceMap<ConfigurationModel> = new StrictResourceMap<ConfigurationModel>();
private _foldersConsolidatedConfigurations: ResourceMap<ConfigurationModel> = new ResourceMap<ConfigurationModel>();
constructor(
private _defaultConfiguration: ConfigurationModel,
private _userConfiguration: ConfigurationModel,
private _workspaceConfiguration: ConfigurationModel = new ConfigurationModel(),
private _folderConfigurations: StrictResourceMap<ConfigurationModel> = new StrictResourceMap<ConfigurationModel>(),
private _folderConfigurations: ResourceMap<ConfigurationModel> = new ResourceMap<ConfigurationModel>(),
private _memoryConfiguration: ConfigurationModel = new ConfigurationModel(),
private _memoryConfigurationByResource: StrictResourceMap<ConfigurationModel> = new StrictResourceMap<ConfigurationModel>()) {
private _memoryConfigurationByResource: ResourceMap<ConfigurationModel> = new ResourceMap<ConfigurationModel>(),
private _freeze: boolean = true) {
}
getValue(section: string, overrides: IConfigurationOverrides, workspace: Workspace): any {
@@ -394,7 +395,7 @@ export class Configuration {
return this._workspaceConfiguration;
}
protected get folders(): StrictResourceMap<ConfigurationModel> {
protected get folders(): ResourceMap<ConfigurationModel> {
return this._folderConfigurations;
}
@@ -422,7 +423,10 @@ export class Configuration {
private getWorkspaceConsolidatedConfiguration(): ConfigurationModel {
if (!this._workspaceConsolidatedConfiguration) {
this._workspaceConsolidatedConfiguration = this._defaultConfiguration.merge(this._userConfiguration).merge(this._workspaceConfiguration).merge(this._memoryConfiguration).freeze();
this._workspaceConsolidatedConfiguration = this._defaultConfiguration.merge(this._userConfiguration, this._workspaceConfiguration, this._memoryConfiguration);
if (this._freeze) {
this._workspaceConfiguration = this._workspaceConfiguration.freeze();
}
}
return this._workspaceConsolidatedConfiguration;
}
@@ -433,7 +437,10 @@ export class Configuration {
const workspaceConsolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
const folderConfiguration = this._folderConfigurations.get(folder);
if (folderConfiguration) {
folderConsolidatedConfiguration = workspaceConsolidateConfiguration.merge(folderConfiguration).freeze();
folderConsolidatedConfiguration = workspaceConsolidateConfiguration.merge(folderConfiguration);
if (this._freeze) {
folderConsolidatedConfiguration = folderConsolidatedConfiguration.freeze();
}
this._foldersConsolidatedConfigurations.set(folder, folderConsolidatedConfiguration);
} else {
folderConsolidatedConfiguration = workspaceConsolidateConfiguration;
@@ -473,7 +480,8 @@ export class Configuration {
const { contents, overrides, keys } = this._folderConfigurations.get(folder);
result[folder.toString()] = { contents, overrides, keys };
return result;
}, Object.create({}))
}, Object.create({})),
isComplete: true
};
}
@@ -494,21 +502,6 @@ export class Configuration {
}
return all;
}
public static parse(data: IConfigurationData): Configuration {
const defaultConfiguration = Configuration.parseConfigurationModel(data.defaults);
const userConfiguration = Configuration.parseConfigurationModel(data.user);
const workspaceConfiguration = Configuration.parseConfigurationModel(data.workspace);
const folders: StrictResourceMap<ConfigurationModel> = Object.keys(data.folders).reduce((result, key) => {
result.set(URI.parse(key), Configuration.parseConfigurationModel(data.folders[key]));
return result;
}, new StrictResourceMap<ConfigurationModel>());
return new Configuration(defaultConfiguration, userConfiguration, workspaceConfiguration, folders);
}
private static parseConfigurationModel(model: IConfigurationModel): ConfigurationModel {
return new ConfigurationModel(model.contents, model.keys, model.overrides).freeze();
}
}
export class AbstractConfigurationChangeEvent {
@@ -542,7 +535,7 @@ export class ConfigurationChangeEvent extends AbstractConfigurationChangeEvent i
constructor(
private _changedConfiguration: ConfigurationModel = new ConfigurationModel(),
private _changedConfigurationByResource: StrictResourceMap<ConfigurationModel> = new StrictResourceMap<ConfigurationModel>()) {
private _changedConfigurationByResource: ResourceMap<ConfigurationModel> = new ResourceMap<ConfigurationModel>()) {
super();
}
@@ -550,7 +543,7 @@ export class ConfigurationChangeEvent extends AbstractConfigurationChangeEvent i
return this._changedConfiguration;
}
get changedConfigurationByResource(): StrictResourceMap<IConfigurationModel> {
get changedConfigurationByResource(): ResourceMap<IConfigurationModel> {
return this._changedConfigurationByResource;
}

51
src/vs/platform/configuration/common/configurationRegistry.ts
View File

@@ -4,14 +4,13 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import nls = require('vs/nls');
import Event, { Emitter } from 'vs/base/common/event';
import * as nls from 'vs/nls';
import { Event, Emitter } from 'vs/base/common/event';
import { IJSONSchema } from 'vs/base/common/jsonSchema';
import { Registry } from 'vs/platform/registry/common/platform';
import types = require('vs/base/common/types');
import * as types from 'vs/base/common/types';
import * as strings from 'vs/base/common/strings';
import { IJSONContributionRegistry, Extensions as JSONExtensions } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
import { deepClone } from 'vs/base/common/objects';
export const Extensions = {
Configuration: 'base.contributions.configuration'
@@ -63,13 +62,13 @@ export interface IConfigurationRegistry {
}
export enum ConfigurationScope {
WINDOW = 1,
RESOURCE
APPLICATION = 1,
WINDOW,
RESOURCE,
}
export interface IConfigurationPropertySchema extends IJSONSchema {
overridable?: boolean;
isExecutable?: boolean;
scope?: ConfigurationScope;
notMultiRootAdopted?: boolean;
included?: boolean;
@@ -93,8 +92,10 @@ export interface IDefaultConfigurationExtension {
defaults: { [key: string]: {} };
}
export const settingsSchema: IJSONSchema = { properties: {}, patternProperties: {}, additionalProperties: false, errorMessage: 'Unknown configuration setting' };
export const resourceSettingsSchema: IJSONSchema = { properties: {}, patternProperties: {}, additionalProperties: false, errorMessage: 'Unknown configuration setting' };
export const allSettings: { properties: {}, patternProperties: {} } = { properties: {}, patternProperties: {} };
export const applicationSettings: { properties: {}, patternProperties: {} } = { properties: {}, patternProperties: {} };
export const windowSettings: { properties: {}, patternProperties: {} } = { properties: {}, patternProperties: {} };
export const resourceSettings: { properties: {}, patternProperties: {} } = { properties: {}, patternProperties: {} };
export const editorConfigurationSchemaId = 'vscode://schemas/settings/editor';
const contributionRegistry = Registry.as<IJSONContributionRegistry>(JSONExtensions.JSONContribution);
@@ -108,7 +109,7 @@ class ConfigurationRegistry implements IConfigurationRegistry {
private overrideIdentifiers: string[] = [];
private overridePropertyPattern: string;
private _onDidRegisterConfiguration: Emitter<string[]> = new Emitter<string[]>();
private readonly _onDidRegisterConfiguration: Emitter<string[]> = new Emitter<string[]>();
readonly onDidRegisterConfiguration: Event<string[]> = this._onDidRegisterConfiguration.event;
constructor() {
@@ -239,10 +240,17 @@ class ConfigurationRegistry implements IConfigurationRegistry {
let properties = configuration.properties;
if (properties) {
for (let key in properties) {
settingsSchema.properties[key] = properties[key];
resourceSettingsSchema.properties[key] = deepClone(properties[key]);
if (properties[key].scope !== ConfigurationScope.RESOURCE) {
resourceSettingsSchema.properties[key].doNotSuggest = true;
allSettings.properties[key] = properties[key];
switch (properties[key].scope) {
case ConfigurationScope.APPLICATION:
applicationSettings.properties[key] = properties[key];
break;
case ConfigurationScope.WINDOW:
windowSettings.properties[key] = properties[key];
break;
case ConfigurationScope.RESOURCE:
resourceSettings.properties[key] = properties[key];
break;
}
}
}
@@ -262,7 +270,7 @@ class ConfigurationRegistry implements IConfigurationRegistry {
}
private updateOverridePropertyPatternKey(): void {
let patternProperties: IJSONSchema = settingsSchema.patternProperties[this.overridePropertyPattern];
let patternProperties: IJSONSchema = allSettings.patternProperties[this.overridePropertyPattern];
if (!patternProperties) {
patternProperties = {
type: 'object',
@@ -271,11 +279,18 @@ class ConfigurationRegistry implements IConfigurationRegistry {
$ref: editorConfigurationSchemaId
};
}
delete settingsSchema.patternProperties[this.overridePropertyPattern];
delete allSettings.patternProperties[this.overridePropertyPattern];
delete applicationSettings.patternProperties[this.overridePropertyPattern];
delete windowSettings.patternProperties[this.overridePropertyPattern];
delete resourceSettings.patternProperties[this.overridePropertyPattern];
this.computeOverridePropertyPattern();
settingsSchema.patternProperties[this.overridePropertyPattern] = patternProperties;
resourceSettingsSchema.patternProperties[this.overridePropertyPattern] = patternProperties;
allSettings.patternProperties[this.overridePropertyPattern] = patternProperties;
applicationSettings.patternProperties[this.overridePropertyPattern] = patternProperties;
windowSettings.patternProperties[this.overridePropertyPattern] = patternProperties;
resourceSettings.patternProperties[this.overridePropertyPattern] = patternProperties;
}
private update(configuration: IConfigurationNode): void {

4
src/vs/platform/configuration/node/configuration.ts
View File

@@ -7,14 +7,14 @@ import { Disposable } from 'vs/base/common/lifecycle';
import { onUnexpectedError } from 'vs/base/common/errors';
import { ConfigurationModelParser, ConfigurationModel } from 'vs/platform/configuration/common/configurationModels';
import { ConfigWatcher } from 'vs/base/node/config';
import Event, { Emitter } from 'vs/base/common/event';
import { Event, Emitter } from 'vs/base/common/event';
import { TPromise } from 'vs/base/common/winjs.base';
export class UserConfiguration extends Disposable {
private userConfigModelWatcher: ConfigWatcher<ConfigurationModelParser>;
private _onDidChangeConfiguration: Emitter<ConfigurationModel> = this._register(new Emitter<ConfigurationModel>());
private readonly _onDidChangeConfiguration: Emitter<ConfigurationModel> = this._register(new Emitter<ConfigurationModel>());
readonly onDidChangeConfiguration: Event<ConfigurationModel> = this._onDidChangeConfiguration.event;
constructor(settingsPath: string) {

4
src/vs/platform/configuration/node/configurationService.ts
View File

@@ -9,7 +9,7 @@ import { IConfigurationRegistry, Extensions } from 'vs/platform/configuration/co
import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
import { IConfigurationService, IConfigurationChangeEvent, IConfigurationOverrides, ConfigurationTarget, compare, isConfigurationOverrides, IConfigurationData } from 'vs/platform/configuration/common/configuration';
import { DefaultConfigurationModel, Configuration, ConfigurationChangeEvent } from 'vs/platform/configuration/common/configurationModels';
import Event, { Emitter } from 'vs/base/common/event';
import { Event, Emitter } from 'vs/base/common/event';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { TPromise } from 'vs/base/common/winjs.base';
import { equals } from 'vs/base/common/objects';
@@ -23,7 +23,7 @@ export class ConfigurationService extends Disposable implements IConfigurationSe
private _configuration: Configuration;
private userConfiguration: UserConfiguration;
private _onDidChangeConfiguration: Emitter<IConfigurationChangeEvent> = this._register(new Emitter<IConfigurationChangeEvent>());
private readonly _onDidChangeConfiguration: Emitter<IConfigurationChangeEvent> = this._register(new Emitter<IConfigurationChangeEvent>());
readonly onDidChangeConfiguration: Event<IConfigurationChangeEvent> = this._onDidChangeConfiguration.event;
constructor(

29
src/vs/platform/configuration/test/common/configurationModels.test.ts
View File

@@ -199,6 +199,17 @@ suite('ConfigurationModel', () => {
assert.deepEqual(result.keys, ['a.b', 'f']);
});
test('merge overrides when frozen', () => {
let model1 = new ConfigurationModel({ 'a': { 'b': 1 }, 'f': 1 }, ['a.b', 'f'], [{ identifiers: ['c'], contents: { 'a': { 'd': 1 } } }]).freeze();
let model2 = new ConfigurationModel({ 'a': { 'b': 2 } }, ['a.b'], [{ identifiers: ['c'], contents: { 'a': { 'e': 2 } } }]).freeze();
let result = new ConfigurationModel().merge(model1, model2);
assert.deepEqual(result.contents, { 'a': { 'b': 2 }, 'f': 1 });
assert.deepEqual(result.overrides, [{ identifiers: ['c'], contents: { 'a': { 'd': 1, 'e': 2 } } }]);
assert.deepEqual(result.override('c').contents, { 'a': { 'b': 2, 'd': 1, 'e': 2 }, 'f': 1 });
assert.deepEqual(result.keys, ['a.b', 'f']);
});
test('Test contents while getting an existing property', () => {
let testObject = new ConfigurationModel({ 'a': 1 });
assert.deepEqual(testObject.getValue('a'), 1);
@@ -349,24 +360,6 @@ suite('CustomConfigurationModel', () => {
});
assert.equal(true, new DefaultConfigurationModel().getValue('a'));
});
test('Test registering the language property', () => {
Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
'id': '[a]',
'order': 1,
'title': 'a',
'type': 'object',
'properties': {
'[a]': {
'description': 'a',
'type': 'boolean',
'default': false,
}
}
});
assert.equal(undefined, new DefaultConfigurationModel().getValue('[a]'));
});
});
suite('ConfigurationChangeEvent', () => {

108
src/vs/platform/configuration/test/node/configurationService.test.ts
View File

@@ -5,20 +5,19 @@
'use strict';
import assert = require('assert');
import os = require('os');
import path = require('path');
import fs = require('fs');
import * as assert from 'assert';
import * as os from 'os';
import * as path from 'path';
import * as fs from 'fs';
import { Registry } from 'vs/platform/registry/common/platform';
import { ConfigurationService } from 'vs/platform/configuration/node/configurationService';
import { ParsedArgs } from 'vs/platform/environment/common/environment';
import { parseArgs } from 'vs/platform/environment/node/argv';
import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
import extfs = require('vs/base/node/extfs');
import uuid = require('vs/base/common/uuid');
import * as uuid from 'vs/base/common/uuid';
import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry';
import { mkdirp } from 'vs/base/node/pfs';
import { testFile } from 'vs/base/test/node/utils';
class SettingsTestEnvironmentService extends EnvironmentService {
@@ -31,22 +30,11 @@ class SettingsTestEnvironmentService extends EnvironmentService {
suite('ConfigurationService - Node', () => {
function testFile(callback: (path: string, cleanUp: (callback: () => void) => void) => void): void {
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');
test('simple', () => {
return testFile('config', 'config.json').then(res => {
fs.writeFileSync(res.testFile, '{ "foo": "bar" }');
const onMkdirp = error => callback(testFile, (callback) => extfs.del(parentDir, os.tmpdir(), () => { }, callback));
mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
}
test('simple', (done: () => void) => {
testFile((testFile, cleanUp) => {
fs.writeFileSync(testFile, '{ "foo": "bar" }');
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, res.testFile));
const config = service.getValue<{ foo: string }>();
assert.ok(config);
@@ -54,15 +42,15 @@ suite('ConfigurationService - Node', () => {
service.dispose();
cleanUp(done);
return res.cleanUp();
});
});
test('config gets flattened', (done: () => void) => {
testFile((testFile, cleanUp) => {
fs.writeFileSync(testFile, '{ "testworkbench.editor.tabs": true }');
test('config gets flattened', () => {
return testFile('config', 'config.json').then(res => {
fs.writeFileSync(res.testFile, '{ "testworkbench.editor.tabs": true }');
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, res.testFile));
const config = service.getValue<{ testworkbench: { editor: { tabs: boolean } } }>();
assert.ok(config);
@@ -72,22 +60,22 @@ suite('ConfigurationService - Node', () => {
service.dispose();
cleanUp(done);
return res.cleanUp();
});
});
test('error case does not explode', (done: () => void) => {
testFile((testFile, cleanUp) => {
fs.writeFileSync(testFile, ',,,,');
test('error case does not explode', () => {
return testFile('config', 'config.json').then(res => {
fs.writeFileSync(res.testFile, ',,,,');
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, res.testFile));
const config = service.getValue<{ foo: string }>();
assert.ok(config);
service.dispose();
cleanUp(done);
return res.cleanUp();
});
});
@@ -105,17 +93,17 @@ suite('ConfigurationService - Node', () => {
service.dispose();
});
test('reloadConfiguration', (done: () => void) => {
testFile((testFile, cleanUp) => {
fs.writeFileSync(testFile, '{ "foo": "bar" }');
test('reloadConfiguration', () => {
return testFile('config', 'config.json').then(res => {
fs.writeFileSync(res.testFile, '{ "foo": "bar" }');
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, res.testFile));
let config = service.getValue<{ foo: string }>();
assert.ok(config);
assert.equal(config.foo, 'bar');
fs.writeFileSync(testFile, '{ "foo": "changed" }');
fs.writeFileSync(res.testFile, '{ "foo": "changed" }');
// still outdated
config = service.getValue<{ foo: string }>();
@@ -123,19 +111,19 @@ suite('ConfigurationService - Node', () => {
assert.equal(config.foo, 'bar');
// force a reload to get latest
service.reloadConfiguration().then(() => {
return service.reloadConfiguration().then(() => {
config = service.getValue<{ foo: string }>();
assert.ok(config);
assert.equal(config.foo, 'changed');
service.dispose();
cleanUp(done);
return res.cleanUp();
});
});
});
test('model defaults', (done: () => void) => {
test('model defaults', () => {
interface ITestSetting {
configuration: {
service: {
@@ -144,7 +132,7 @@ suite('ConfigurationService - Node', () => {
};
}
const configurationRegistry = <IConfigurationRegistry>Registry.as(ConfigurationExtensions.Configuration);
const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
configurationRegistry.registerConfiguration({
'id': '_test',
'type': 'object',
@@ -162,19 +150,19 @@ suite('ConfigurationService - Node', () => {
assert.ok(setting);
assert.equal(setting.configuration.service.testSetting, 'isSet');
testFile((testFile, cleanUp) => {
fs.writeFileSync(testFile, '{ "testworkbench.editor.tabs": true }');
return testFile('config', 'config.json').then(res => {
fs.writeFileSync(res.testFile, '{ "testworkbench.editor.tabs": true }');
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, res.testFile));
let setting = service.getValue<ITestSetting>();
assert.ok(setting);
assert.equal(setting.configuration.service.testSetting, 'isSet');
fs.writeFileSync(testFile, '{ "configuration.service.testSetting": "isChanged" }');
fs.writeFileSync(res.testFile, '{ "configuration.service.testSetting": "isChanged" }');
service.reloadConfiguration().then(() => {
return service.reloadConfiguration().then(() => {
let setting = service.getValue<ITestSetting>();
assert.ok(setting);
@@ -183,13 +171,13 @@ suite('ConfigurationService - Node', () => {
service.dispose();
serviceWithoutFile.dispose();
cleanUp(done);
return res.cleanUp();
});
});
});
test('lookup', (done: () => void) => {
const configurationRegistry = <IConfigurationRegistry>Registry.as(ConfigurationExtensions.Configuration);
test('lookup', () => {
const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
configurationRegistry.registerConfiguration({
'id': '_test',
'type': 'object',
@@ -201,8 +189,8 @@ suite('ConfigurationService - Node', () => {
}
});
testFile((testFile, cleanUp) => {
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
return testFile('config', 'config.json').then(r => {
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, r.testFile));
let res = service.inspect('something.missing');
assert.strictEqual(res.value, void 0);
@@ -214,7 +202,7 @@ suite('ConfigurationService - Node', () => {
assert.strictEqual(res.value, 'isSet');
assert.strictEqual(res.user, void 0);
fs.writeFileSync(testFile, '{ "lookup.service.testSetting": "bar" }');
fs.writeFileSync(r.testFile, '{ "lookup.service.testSetting": "bar" }');
return service.reloadConfiguration().then(() => {
res = service.inspect('lookup.service.testSetting');
@@ -224,13 +212,13 @@ suite('ConfigurationService - Node', () => {
service.dispose();
cleanUp(done);
return r.cleanUp();
});
});
});
test('lookup with null', (done: () => void) => {
const configurationRegistry = <IConfigurationRegistry>Registry.as(ConfigurationExtensions.Configuration);
test('lookup with null', () => {
const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration);
configurationRegistry.registerConfiguration({
'id': '_testNull',
'type': 'object',
@@ -241,15 +229,15 @@ suite('ConfigurationService - Node', () => {
}
});
testFile((testFile, cleanUp) => {
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
return testFile('config', 'config.json').then(r => {
const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, r.testFile));
let res = service.inspect('lookup.service.testNullSetting');
assert.strictEqual(res.default, null);
assert.strictEqual(res.value, null);
assert.strictEqual(res.user, void 0);
fs.writeFileSync(testFile, '{ "lookup.service.testNullSetting": null }');
fs.writeFileSync(r.testFile, '{ "lookup.service.testNullSetting": null }');
return service.reloadConfiguration().then(() => {
res = service.inspect('lookup.service.testNullSetting');
@@ -259,7 +247,7 @@ suite('ConfigurationService - Node', () => {
service.dispose();
cleanUp(done);
return r.cleanUp();
});
});
});