ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 18:46:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

Fix more floating promises (#8374)

Browse Source 
* Fix more floating promises

* Fix a few more

* Test fixes

* Fix spellings

* More promise fixes

* couple more

* Few more fixes

* One more missed one
This commit is contained in:
Charles Gagnon
2019-11-18 17:11:25 -08:00
committed by GitHub
parent 840683e3f0
commit 5b50696a1b
8 changed files with 231 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/sql/workbench/contrib/profiler/browser/profilerFilterDialog.ts
View File

@@ -27,6 +27,7 @@ import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/la
import { ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration'; import { ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration';
import { find, firstIndex } from 'vs/base/common/arrays'; import { find, firstIndex } from 'vs/base/common/arrays';
import { IAdsTelemetryService } from 'sql/platform/telemetry/common/telemetry'; import { IAdsTelemetryService } from 'sql/platform/telemetry/common/telemetry';
import { onUnexpectedError } from 'vs/base/common/errors';
const ClearText: string = localize('profilerFilterDialog.clear', "Clear all"); const ClearText: string = localize('profilerFilterDialog.clear', "Clear all");
@@ -184,7 +185,7 @@ export class ProfilerFilterDialog extends Modal {
} }
private saveFilter(): void { private saveFilter(): void {
this.profilerService.saveFilter(this.getFilter()); this.profilerService.saveFilter(this.getFilter()).catch(e => onUnexpectedError(e));
} }
private loadSavedFilter(): void { private loadSavedFilter(): void {

7
src/sql/workbench/services/dialog/browser/dialogModal.ts
View File

@@ -24,6 +24,7 @@ import { append, $ } from 'vs/base/browser/dom';
import { ILogService } from 'vs/platform/log/common/log'; import { ILogService } from 'vs/platform/log/common/log';
import { ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration'; import { ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration';
import { IAdsTelemetryService } from 'sql/platform/telemetry/common/telemetry'; import { IAdsTelemetryService } from 'sql/platform/telemetry/common/telemetry';
import { onUnexpectedError } from 'vs/base/common/errors';
export class DialogModal extends Modal { export class DialogModal extends Modal {
private _dialogPane: DialogPane; private _dialogPane: DialogPane;
@@ -156,15 +157,15 @@ export class DialogModal extends Modal {
/** /**
* Overridable to change behavior of escape key * Overridable to change behavior of escape key
*/ */
protected onClose(e: StandardKeyboardEvent) { protected onClose(e: StandardKeyboardEvent): void {
this.cancel(); this.cancel();
} }
/** /**
* Overridable to change behavior of enter key * Overridable to change behavior of enter key
*/ */
protected onAccept(e: StandardKeyboardEvent) { protected onAccept(e: StandardKeyboardEvent): void {
this.done(); this.done().catch(err => onUnexpectedError(err));
} }
public dispose(): void { public dispose(): void {

20
src/sql/workbench/services/dialog/browser/wizardModal.ts
View File

@@ -25,6 +25,7 @@ import { ILogService } from 'vs/platform/log/common/log';
import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService'; import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService';
import { ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration'; import { ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration';
import { IAdsTelemetryService } from 'sql/platform/telemetry/common/telemetry'; import { IAdsTelemetryService } from 'sql/platform/telemetry/common/telemetry';
import { onUnexpectedError } from 'vs/base/common/errors';
export class WizardModal extends Modal { export class WizardModal extends Modal {
private _dialogPanes = new Map<WizardPage, DialogPane>(); private _dialogPanes = new Map<WizardPage, DialogPane>();
@@ -139,13 +140,13 @@ export class WizardModal extends Modal {
this._wizard.onPageAdded(page => { this._wizard.onPageAdded(page => {
this.registerPage(page); this.registerPage(page);
this.updatePageNumbers(); this.updatePageNumbers();
this.showPage(this._wizard.currentPage, false); this.showPage(this._wizard.currentPage, false).catch(err => onUnexpectedError(err));
}); });
this._wizard.onPageRemoved(page => { this._wizard.onPageRemoved(page => {
let dialogPane = this._dialogPanes.get(page); let dialogPane = this._dialogPanes.get(page);
this._dialogPanes.delete(page); this._dialogPanes.delete(page);
this.updatePageNumbers(); this.updatePageNumbers();
this.showPage(this._wizard.currentPage, false); this.showPage(this._wizard.currentPage, false).catch(err => onUnexpectedError(err));
dialogPane.dispose(); dialogPane.dispose();
}); });
this.updatePageNumbers(); this.updatePageNumbers();
@@ -168,7 +169,7 @@ export class WizardModal extends Modal {
private async showPage(index: number, validate: boolean = true, focus: boolean = false): Promise<void> { private async showPage(index: number, validate: boolean = true, focus: boolean = false): Promise<void> {
let pageToShow = this._wizard.pages[index]; let pageToShow = this._wizard.pages[index];
if (!pageToShow) { if (!pageToShow) {
this.done(validate); this.done(validate).catch(err => onUnexpectedError(err));
return; return;
} }
if (validate && !await this.validateNavigation(index)) { if (validate && !await this.validateNavigation(index)) {
@@ -235,8 +236,9 @@ export class WizardModal extends Modal {
} }
public open(): void { public open(): void {
this.showPage(0, false, true); this.showPage(0, false, true).then(() => {
this.show(); this.show();
}).catch(err => onUnexpectedError(err));
} }
public async done(validate: boolean = true): Promise<void> { public async done(validate: boolean = true): Promise<void> {
@@ -281,19 +283,19 @@ export class WizardModal extends Modal {
/** /**
* Overridable to change behavior of escape key * Overridable to change behavior of escape key
*/ */
protected onClose(e: StandardKeyboardEvent) { protected onClose(e: StandardKeyboardEvent): void {
this.cancel(); this.cancel();
} }
/** /**
* Overridable to change behavior of enter key * Overridable to change behavior of enter key
*/ */
protected onAccept(e: StandardKeyboardEvent) { protected onAccept(e: StandardKeyboardEvent): void {
if (this._wizard.currentPage === this._wizard.pages.length - 1) { if (this._wizard.currentPage === this._wizard.pages.length - 1) {
this.done(); this.done().catch(err => onUnexpectedError(err));
} else { } else {
if (this._nextButton.enabled) { if (this._nextButton.enabled) {
this.showPage(this._wizard.currentPage + 1, true, true); this.showPage(this._wizard.currentPage + 1, true, true).catch(err => onUnexpectedError(err));
} }
} }
} }

22
src/sql/workbench/services/notebook/browser/sql/sqlSessionManager.ts
View File

@@ -27,6 +27,7 @@ import { URI } from 'vs/base/common/uri';
import { getUriPrefix, uriPrefixes } from 'sql/platform/connection/common/utils'; import { getUriPrefix, uriPrefixes } from 'sql/platform/connection/common/utils';
import { firstIndex } from 'vs/base/common/arrays'; import { firstIndex } from 'vs/base/common/arrays';
import { startsWith } from 'vs/base/common/strings'; import { startsWith } from 'vs/base/common/strings';
import { onUnexpectedError } from 'vs/base/common/errors';
export const sqlKernelError: string = localize("sqlKernelError", "SQL kernel error"); export const sqlKernelError: string = localize("sqlKernelError", "SQL kernel error");
export const MAX_ROWS = 5000; export const MAX_ROWS = 5000;
@@ -276,15 +277,15 @@ class SqlKernel extends Disposable implements nb.IKernel {
if (this._future && !this._queryRunner.hasCompleted) { if (this._future && !this._queryRunner.hasCompleted) {
this._queryRunner.cancelQuery().then(ok => undefined, error => this._errorMessageService.showDialog(Severity.Error, sqlKernelError, error)); this._queryRunner.cancelQuery().then(ok => undefined, error => this._errorMessageService.showDialog(Severity.Error, sqlKernelError, error));
// TODO when we can just show error as an output, should show an "execution canceled" error in output // TODO when we can just show error as an output, should show an "execution canceled" error in output
this._future.handleDone(); this._future.handleDone().catch(err => onUnexpectedError(err));
} }
this._queryRunner.runQuery(code); this._queryRunner.runQuery(code).catch(err => onUnexpectedError(err));
} else if (this._currentConnection && this._currentConnectionProfile) { } else if (this._currentConnection && this._currentConnectionProfile) {
this._queryRunner = this._instantiationService.createInstance(QueryRunner, this._connectionPath); this._queryRunner = this._instantiationService.createInstance(QueryRunner, this._connectionPath);
this._connectionManagementService.connect(this._currentConnectionProfile, this._connectionPath).then((result) => { this._connectionManagementService.connect(this._currentConnectionProfile, this._connectionPath).then((result) => {
this.addQueryEventListeners(this._queryRunner); this.addQueryEventListeners(this._queryRunner);
this._queryRunner.runQuery(code); this._queryRunner.runQuery(code).catch(err => onUnexpectedError(err));
}); }).catch(err => onUnexpectedError(err));
} else { } else {
canRun = false; canRun = false;
} }
@@ -296,7 +297,7 @@ class SqlKernel extends Disposable implements nb.IKernel {
this._future = new SQLFuture(this._queryRunner, count, this._configurationService, this.logService); this._future = new SQLFuture(this._queryRunner, count, this._configurationService, this.logService);
if (!canRun) { if (!canRun) {
// Complete early // Complete early
this._future.handleDone(new Error(localize('connectionRequired', "A connection must be chosen to run notebook cells"))); this._future.handleDone(new Error(localize('connectionRequired', "A connection must be chosen to run notebook cells"))).catch(err => onUnexpectedError(err));
} }
// TODO should we cleanup old future? I don't think we need to // TODO should we cleanup old future? I don't think we need to
@@ -354,7 +355,7 @@ class SqlKernel extends Disposable implements nb.IKernel {
private async queryComplete(): Promise<void> { private async queryComplete(): Promise<void> {
if (this._future) { if (this._future) {
this._future.handleDone(); await this._future.handleDone();
} }
// TODO issue #2746 should ideally show a warning inside the dialog if have no data // TODO issue #2746 should ideally show a warning inside the dialog if have no data
} }
@@ -405,7 +406,7 @@ export class SQLFuture extends Disposable implements FutureInternal {
} }
set inProgress(val: boolean) { set inProgress(val: boolean) {
if (this._queryRunner && !val) { if (this._queryRunner && !val) {
this._queryRunner.cancelQuery(); this._queryRunner.cancelQuery().catch(err => onUnexpectedError(err));
} }
} }
get msg(): nb.IMessage { get msg(): nb.IMessage {
@@ -416,12 +417,7 @@ export class SQLFuture extends Disposable implements FutureInternal {
return this.doneDeferred.promise; return this.doneDeferred.promise;
} }
public handleDone(err?: Error): void { public async handleDone(err?: Error): Promise<void> {
this.handleDoneAsync(err);
// TODO we should reject where some failure happened?
}
private async handleDoneAsync(err?: Error): Promise<void> {
// must wait on all outstanding output updates to complete // must wait on all outstanding output updates to complete
if (this._outputAddedPromises && this._outputAddedPromises.length > 0) { if (this._outputAddedPromises && this._outputAddedPromises.length > 0) {
// Do not care about error handling as this is handled elsewhere // Do not care about error handling as this is handled elsewhere

479
src/sql/workbench/services/objectExplorer/test/browser/objectExplorerService.test.ts
View File

@@ -42,7 +42,7 @@ suite('SQL Object Explorer Service tests', () => {
setup(() => { setup(() => {
let NodeInfoTable1 = { const NodeInfoTable1 = {
nodePath: 'testServerName/tables/dbo.Table1', nodePath: 'testServerName/tables/dbo.Table1',
nodeType: NodeType.Table, nodeType: NodeType.Table,
label: 'dbo.Table1', label: 'dbo.Table1',
@@ -52,7 +52,7 @@ suite('SQL Object Explorer Service tests', () => {
nodeStatus: '', nodeStatus: '',
errorMessage: '' errorMessage: ''
}; };
let NodeInfoTable2 = { const NodeInfoTable2 = {
nodePath: 'testServerName/tables/dbo.Table2', nodePath: 'testServerName/tables/dbo.Table2',
nodeType: NodeType.Table, nodeType: NodeType.Table,
label: 'dbo.Table2', label: 'dbo.Table2',
@@ -63,7 +63,7 @@ suite('SQL Object Explorer Service tests', () => {
errorMessage: '' errorMessage: ''
}; };
let NodeInfoTable3 = { const NodeInfoTable3 = {
nodePath: 'testServerName/tables/dbo.Table3', nodePath: 'testServerName/tables/dbo.Table3',
nodeType: NodeType.Table, nodeType: NodeType.Table,
label: 'dbo.Table3', label: 'dbo.Table3',
@@ -117,18 +117,18 @@ suite('SQL Object Explorer Service tests', () => {
nodePath: objectExplorerSession.rootNode.nodePath, nodePath: objectExplorerSession.rootNode.nodePath,
providerId: mssqlProviderName providerId: mssqlProviderName
}; };
let response: azdata.ObjectExplorerSessionResponse = { const response: azdata.ObjectExplorerSessionResponse = {
sessionId: objectExplorerSession.sessionId sessionId: objectExplorerSession.sessionId
}; };
let failedResponse: azdata.ObjectExplorerSessionResponse = { const failedResponse: azdata.ObjectExplorerSessionResponse = {
sessionId: failedSessionId sessionId: failedSessionId
}; };
sqlOEProvider = TypeMoq.Mock.ofType(TestObjectExplorerProvider, TypeMoq.MockBehavior.Loose); sqlOEProvider = TypeMoq.Mock.ofType(TestObjectExplorerProvider, TypeMoq.MockBehavior.Loose);
sqlOEProvider.callBase = true; sqlOEProvider.callBase = true;
let sqlProvider = { const sqlProvider = {
providerId: mssqlProviderName, providerId: mssqlProviderName,
displayName: 'MSSQL', displayName: 'MSSQL',
connectionOptions: [ connectionOptions: [
@@ -219,7 +219,7 @@ suite('SQL Object Explorer Service tests', () => {
] ]
}; };
let capabilitiesService = new TestCapabilitiesService(); const capabilitiesService = new TestCapabilitiesService();
capabilitiesService.capabilities[mssqlProviderName] = { connection: sqlProvider }; capabilitiesService.capabilities[mssqlProviderName] = { connection: sqlProvider };
connection = new ConnectionProfile(capabilitiesService, { connection = new ConnectionProfile(capabilitiesService, {
@@ -298,178 +298,126 @@ suite('SQL Object Explorer Service tests', () => {
} as ServerTreeView); } as ServerTreeView);
}); });
test('create new session should create session successfully', (done) => { test('create new session should create session successfully', async () => {
objectExplorerService.createNewSession(mssqlProviderName, connection).then(session => { const session = await objectExplorerService.createNewSession(mssqlProviderName, connection);
assert.equal(session !== null || session !== undefined, true); assert.equal(session !== null || session !== undefined, true);
assert.equal(session.sessionId, '1234'); assert.equal(session.sessionId, '1234');
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
let node = objectExplorerService.getObjectExplorerNode(connection); const node = objectExplorerService.getObjectExplorerNode(connection);
assert.notEqual(node, undefined); assert.notEqual(node, undefined);
assert.equal(node.session.success, true); assert.equal(node.session.success, true);
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
}); });
test('create new session should raise failed event for failed session', (done) => { test('create new session should raise failed event for failed session', async () => {
objectExplorerService.createNewSession(mssqlProviderName, connectionToFail).then(session => { const session = await objectExplorerService.createNewSession(mssqlProviderName, connectionToFail);
assert.equal(session !== null || session !== undefined, true); assert.equal(session !== null || session !== undefined, true);
assert.equal(session.sessionId, failedSessionId); assert.equal(session.sessionId, failedSessionId);
let currentNumberOfSuccessfulSessions = numberOfSuccessfulSessions; const currentNumberOfSuccessfulSessions = numberOfSuccessfulSessions;
objectExplorerService.onSessionCreated(1, objectExplorerFailedSession); objectExplorerService.onSessionCreated(1, objectExplorerFailedSession);
let node = objectExplorerService.getObjectExplorerNode(connection); const node = objectExplorerService.getObjectExplorerNode(connection);
assert.equal(node, undefined); assert.equal(node, undefined);
assert.equal(currentNumberOfSuccessfulSessions, numberOfSuccessfulSessions); assert.equal(currentNumberOfSuccessfulSessions, numberOfSuccessfulSessions);
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
}); });
test('close session should close session successfully', (done) => { test('close session should close session successfully', async () => {
objectExplorerService.closeSession(mssqlProviderName, objectExplorerSession).then(session => { const session = await objectExplorerService.closeSession(mssqlProviderName, objectExplorerSession);
assert.equal(session !== null || session !== undefined, true); assert.equal(session !== null || session !== undefined, true);
assert.equal(session.success, true); assert.equal(session.success, true);
assert.equal(session.sessionId, '1234'); assert.equal(session.sessionId, '1234');
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
}); });
test('expand node should expand node correctly', (done) => { test('expand node should expand node correctly', async () => {
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.expandNode(mssqlProviderName, objectExplorerSession, 'testServerName/tables').then(expandInfo => { const expandInfo = await objectExplorerService.expandNode(mssqlProviderName, objectExplorerSession, 'testServerName/tables');
assert.equal(expandInfo !== null || expandInfo !== undefined, true); assert.equal(expandInfo !== null || expandInfo !== undefined, true);
assert.equal(expandInfo.sessionId, '1234'); assert.equal(expandInfo.sessionId, '1234');
assert.equal(expandInfo.nodes.length, 2); assert.equal(expandInfo.nodes.length, 2);
let children = expandInfo.nodes; const children = expandInfo.nodes;
assert.equal(children[0].label, 'dbo.Table1'); assert.equal(children[0].label, 'dbo.Table1');
assert.equal(children[1].label, 'dbo.Table2'); assert.equal(children[1].label, 'dbo.Table2');
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
});
}); });
test('refresh node should refresh node correctly', (done) => { test('refresh node should refresh node correctly', async () => {
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.refreshNode(mssqlProviderName, objectExplorerSession, 'testServerName/tables').then(expandInfo => { const expandInfo = await objectExplorerService.refreshNode(mssqlProviderName, objectExplorerSession, 'testServerName/tables');
assert.equal(expandInfo !== null || expandInfo !== undefined, true); assert.equal(expandInfo !== null || expandInfo !== undefined, true);
assert.equal(expandInfo.sessionId, '1234'); assert.equal(expandInfo.sessionId, '1234');
assert.equal(expandInfo.nodes.length, 2); assert.equal(expandInfo.nodes.length, 2);
let children = expandInfo.nodes; const children = expandInfo.nodes;
assert.equal(children[0].label, 'dbo.Table1'); assert.equal(children[0].label, 'dbo.Table1');
assert.equal(children[1].label, 'dbo.Table3'); assert.equal(children[1].label, 'dbo.Table3');
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
});
}); });
test('expand tree node should get correct children', (done) => { test('expand tree node should get correct children', async () => {
let tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName/tables', '', '', null, null, undefined, undefined); const tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName/tables', '', '', null, null, undefined, undefined);
tablesNode.connection = connection; tablesNode.connection = connection;
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, tablesNode).then(children => { const children = await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, tablesNode);
assert.equal(children !== null || children !== undefined, true); assert.equal(children !== null || children !== undefined, true);
assert.equal(children[0].label, 'dbo.Table1'); assert.equal(children[0].label, 'dbo.Table1');
assert.equal(children[0].parent, tablesNode); assert.equal(children[0].parent, tablesNode);
assert.equal(children[0].nodePath, 'testServerName/tables/dbo.Table1'); assert.equal(children[0].nodePath, 'testServerName/tables/dbo.Table1');
assert.equal(children[1].label, 'dbo.Table2'); assert.equal(children[1].label, 'dbo.Table2');
assert.equal(children[1].parent, tablesNode); assert.equal(children[1].parent, tablesNode);
assert.equal(children[1].nodePath, 'testServerName/tables/dbo.Table2'); assert.equal(children[1].nodePath, 'testServerName/tables/dbo.Table2');
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
});
}); });
test('refresh tree node should children correctly', (done) => { test('refresh tree node should children correctly', async () => {
let tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName/tables', '', '', null, null, undefined, undefined); const tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName/tables', '', '', null, null, undefined, undefined);
tablesNode.connection = connection; tablesNode.connection = connection;
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.refreshTreeNode(objectExplorerSession, tablesNode).then(children => { const children = await objectExplorerService.refreshTreeNode(objectExplorerSession, tablesNode);
assert.equal(children !== null || children !== undefined, true); assert.equal(children !== null || children !== undefined, true);
assert.equal(children[0].label, 'dbo.Table1'); assert.equal(children[0].label, 'dbo.Table1');
assert.equal(children[0].parent, tablesNode); assert.equal(children[0].parent, tablesNode);
assert.equal(children[0].nodePath, 'testServerName/tables/dbo.Table1'); assert.equal(children[0].nodePath, 'testServerName/tables/dbo.Table1');
assert.equal(children[1].label, 'dbo.Table3'); assert.equal(children[1].label, 'dbo.Table3');
assert.equal(children[1].parent, tablesNode); assert.equal(children[1].parent, tablesNode);
assert.equal(children[1].nodePath, 'testServerName/tables/dbo.Table3'); assert.equal(children[1].nodePath, 'testServerName/tables/dbo.Table3');
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
});
}); });
test('update object explorer nodes should get active connection, create session, add to the active OE nodes successfully', (done) => { test('update object explorer nodes should get active connection, create session, add to the active OE nodes successfully', async () => {
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.updateObjectExplorerNodes(connection).then(() => { await objectExplorerService.updateObjectExplorerNodes(connection);
let treeNode = objectExplorerService.getObjectExplorerNode(connection); const treeNode = objectExplorerService.getObjectExplorerNode(connection);
assert.equal(treeNode !== null || treeNode !== undefined, true); assert.equal(treeNode !== null || treeNode !== undefined, true);
assert.equal(treeNode.getSession(), objectExplorerSession); assert.equal(treeNode.getSession(), objectExplorerSession);
assert.equal(treeNode.getConnectionProfile(), connection); assert.equal(treeNode.getConnectionProfile(), connection);
assert.equal(treeNode.label, 'Tables'); assert.equal(treeNode.label, 'Tables');
assert.equal(treeNode.nodePath, 'testServerName/tables'); assert.equal(treeNode.nodePath, 'testServerName/tables');
done();
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
});
}); });
test('delete object explorerNode nodes should delete session, delete the root node to the active OE node', (done) => { test('delete object explorerNode nodes should delete session, delete the root node to the active OE node', async () => {
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.updateObjectExplorerNodes(connection).then(() => { await objectExplorerService.updateObjectExplorerNodes(connection);
let treeNode = objectExplorerService.getObjectExplorerNode(connection); let treeNode = objectExplorerService.getObjectExplorerNode(connection);
assert.equal(treeNode !== null && treeNode !== undefined, true); assert.equal(treeNode !== null && treeNode !== undefined, true);
objectExplorerService.deleteObjectExplorerNode(connection).then(() => { await objectExplorerService.deleteObjectExplorerNode(connection);
treeNode = objectExplorerService.getObjectExplorerNode(connection); treeNode = objectExplorerService.getObjectExplorerNode(connection);
assert.equal(treeNode === null || treeNode === undefined, true); assert.equal(treeNode === null || treeNode === undefined, true);
done();
});
}, err => {
// Must call done here so test indicates it's finished if errors occur
done(err);
});
});
}); });
test('children tree nodes should return correct object explorer session, connection profile and database name', () => { test('children tree nodes should return correct object explorer session, connection profile and database name', () => {
let databaseMetaData = { const databaseMetaData = {
metadataType: 0, metadataType: 0,
metadataTypeName: 'Database', metadataTypeName: 'Database',
urn: '//server/db1/', urn: '//server/db1/',
name: 'Db1', name: 'Db1',
schema: null schema: null
}; };
let databaseNode = new TreeNode(NodeType.Database, 'Db1', false, 'testServerName\\Db1', '', '', null, databaseMetaData, undefined, undefined); const databaseNode = new TreeNode(NodeType.Database, 'Db1', false, 'testServerName\\Db1', '', '', null, databaseMetaData, undefined, undefined);
databaseNode.connection = connection; databaseNode.connection = connection;
databaseNode.session = objectExplorerSession; databaseNode.session = objectExplorerSession;
let tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName\\Db1\\tables', '', '', databaseNode, null, undefined, undefined); const tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName\\Db1\\tables', '', '', databaseNode, null, undefined, undefined);
databaseNode.children = [tablesNode]; databaseNode.children = [tablesNode];
let table1Node = new TreeNode(NodeType.Table, 'dbo.Table1', false, 'testServerName\\Db1\\tables\\dbo.Table1', '', '', tablesNode, null, undefined, undefined); const table1Node = new TreeNode(NodeType.Table, 'dbo.Table1', false, 'testServerName\\Db1\\tables\\dbo.Table1', '', '', tablesNode, null, undefined, undefined);
let table2Node = new TreeNode(NodeType.Table, 'dbo.Table2', false, 'testServerName\\Db1\\tables\\dbo.Table2', '', '', tablesNode, null, undefined, undefined); const table2Node = new TreeNode(NodeType.Table, 'dbo.Table2', false, 'testServerName\\Db1\\tables\\dbo.Table2', '', '', tablesNode, null, undefined, undefined);
tablesNode.children = [table1Node, table2Node]; tablesNode.children = [table1Node, table2Node];
assert.equal(table1Node.getSession(), objectExplorerSession); assert.equal(table1Node.getSession(), objectExplorerSession);
assert.equal(table1Node.getConnectionProfile(), connection); assert.equal(table1Node.getConnectionProfile(), connection);
@@ -477,61 +425,61 @@ suite('SQL Object Explorer Service tests', () => {
}); });
test('getSelectedProfileAndDatabase returns the profile if it is selected', () => { test('getSelectedProfileAndDatabase returns the profile if it is selected', () => {
let serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView); const serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView);
serverTreeView.setup(x => x.getSelection()).returns(() => [connection]); serverTreeView.setup(x => x.getSelection()).returns(() => [connection]);
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
let selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase(); const selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase();
assert.equal(selectedProfileAndDatabase.profile, connection); assert.equal(selectedProfileAndDatabase.profile, connection);
assert.equal(selectedProfileAndDatabase.databaseName, undefined); assert.equal(selectedProfileAndDatabase.databaseName, undefined);
}); });
test('getSelectedProfileAndDatabase returns the profile but no database if children of a server are selected', () => { test('getSelectedProfileAndDatabase returns the profile but no database if children of a server are selected', () => {
let serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView); const serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView);
let databaseNode = new TreeNode(NodeType.Folder, 'Folder1', false, 'testServerName\\Folder1', '', '', undefined, undefined, undefined, undefined); const databaseNode = new TreeNode(NodeType.Folder, 'Folder1', false, 'testServerName\\Folder1', '', '', undefined, undefined, undefined, undefined);
databaseNode.connection = connection; databaseNode.connection = connection;
serverTreeView.setup(x => x.getSelection()).returns(() => [databaseNode]); serverTreeView.setup(x => x.getSelection()).returns(() => [databaseNode]);
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
let selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase(); const selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase();
assert.equal(selectedProfileAndDatabase.profile, connection); assert.equal(selectedProfileAndDatabase.profile, connection);
assert.equal(selectedProfileAndDatabase.databaseName, undefined); assert.equal(selectedProfileAndDatabase.databaseName, undefined);
}); });
test('getSelectedProfileAndDatabase returns the profile and database if children of a database node are selected', () => { test('getSelectedProfileAndDatabase returns the profile and database if children of a database node are selected', () => {
let serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView); const serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView);
let databaseMetadata = { const databaseMetadata = {
metadataType: 0, metadataType: 0,
metadataTypeName: 'Database', metadataTypeName: 'Database',
urn: '//server/db1/', urn: '//server/db1/',
name: 'Db1', name: 'Db1',
schema: undefined schema: undefined
}; };
let databaseName = 'Db1'; const databaseName = 'Db1';
let databaseNode = new TreeNode(NodeType.Database, databaseName, false, 'testServerName\\Db1', '', '', undefined, databaseMetadata, undefined, undefined); const databaseNode = new TreeNode(NodeType.Database, databaseName, false, 'testServerName\\Db1', '', '', undefined, databaseMetadata, undefined, undefined);
let tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName\\Db1\\tables', '', '', databaseNode, undefined, undefined, undefined); const tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, 'testServerName\\Db1\\tables', '', '', databaseNode, undefined, undefined, undefined);
databaseNode.connection = connection; databaseNode.connection = connection;
databaseNode.children = [tablesNode]; databaseNode.children = [tablesNode];
serverTreeView.setup(x => x.getSelection()).returns(() => [tablesNode]); serverTreeView.setup(x => x.getSelection()).returns(() => [tablesNode]);
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
let selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase(); const selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase();
assert.equal(selectedProfileAndDatabase.profile, connection); assert.equal(selectedProfileAndDatabase.profile, connection);
assert.equal(selectedProfileAndDatabase.databaseName, databaseName); assert.equal(selectedProfileAndDatabase.databaseName, databaseName);
}); });
test('getSelectedProfileAndDatabase returns undefined when there is no selection', () => { test('getSelectedProfileAndDatabase returns undefined when there is no selection', () => {
let serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView); const serverTreeView = TypeMoq.Mock.ofInstance({ getSelection: () => undefined, onSelectionOrFocusChange: Event.None } as ServerTreeView);
serverTreeView.setup(x => x.getSelection()).returns(() => []); serverTreeView.setup(x => x.getSelection()).returns(() => []);
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
let selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase(); const selectedProfileAndDatabase = objectExplorerService.getSelectedProfileAndDatabase();
assert.equal(selectedProfileAndDatabase, undefined); assert.equal(selectedProfileAndDatabase, undefined);
}); });
test('isExpanded returns true when the node and its parents are expanded', (done) => { test('isExpanded returns true when the node and its parents are expanded', async () => {
let table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath; const table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath;
let tableExpandInfo = { const tableExpandInfo = {
sessionId: sessionId, sessionId: sessionId,
nodes: [], nodes: [],
errorMessage: '', errorMessage: '',
@@ -542,54 +490,36 @@ suite('SQL Object Explorer Service tests', () => {
return treeNode === connection || treeNode.nodePath === table1NodePath; return treeNode === connection || treeNode.nodePath === table1NodePath;
}); });
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection)).then(childNodes => { const childNodes = await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection));
sqlOEProvider.setup(x => x.expandNode(TypeMoq.It.isAny())).callback(() => { sqlOEProvider.setup(x => x.expandNode(TypeMoq.It.isAny())).callback(() => {
objectExplorerService.onNodeExpanded(tableExpandInfo); objectExplorerService.onNodeExpanded(tableExpandInfo);
}).returns(() => Promise.resolve(true)); }).returns(() => Promise.resolve(true));
let tableNode = find(childNodes, node => node.nodePath === table1NodePath); const tableNode = find(childNodes, node => node.nodePath === table1NodePath);
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, tableNode).then(() => { await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, tableNode);
// If I check whether the table is expanded, the answer should be yes const isExpanded = await tableNode.isExpanded();
tableNode.isExpanded().then(isExpanded => { assert.equal(isExpanded, true, 'Table node was not expanded');
try {
assert.equal(isExpanded, true);
done();
} catch (err) {
done(err);
}
}, err => done(err));
}, err => done(err));
}, err => done(err));
}, err => done(err));
}); });
test('isExpanded returns false when the node is not expanded', (done) => { test('isExpanded returns false when the node is not expanded', async () => {
let table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath; const table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath;
serverTreeView.setup(x => x.isExpanded(TypeMoq.It.isAny())).returns(treeNode => { serverTreeView.setup(x => x.isExpanded(TypeMoq.It.isAny())).returns(treeNode => {
return treeNode === connection; return treeNode === connection;
}); });
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection)).then(childNodes => { const childNodes = await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection));
// If I check whether the table is expanded, the answer should be no because only its parent node is expanded // If I check whether the table is expanded, the answer should be no because only its parent node is expanded
let tableNode = find(childNodes, node => node.nodePath === table1NodePath); const tableNode = find(childNodes, node => node.nodePath === table1NodePath);
tableNode.isExpanded().then(isExpanded => { const isExpanded = await tableNode.isExpanded();
try { assert.equal(isExpanded, false);
assert.equal(isExpanded, false);
done();
} catch (err) {
done(err);
}
}, err => done(err));
}, err => done(err));
}, err => done(err));
}); });
test('isExpanded returns false when the parent of the requested node is not expanded', (done) => { test('isExpanded returns false when the parent of the requested node is not expanded', (done) => {
let table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath; const table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath;
let tableExpandInfo = { const tableExpandInfo = {
sessionId: sessionId, sessionId: sessionId,
nodes: [], nodes: [],
errorMessage: '', errorMessage: '',
@@ -608,7 +538,7 @@ suite('SQL Object Explorer Service tests', () => {
}).returns(() => Promise.resolve(true)); }).returns(() => Promise.resolve(true));
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, find(childNodes, node => node.nodePath === table1NodePath)).then(() => { objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, find(childNodes, node => node.nodePath === table1NodePath)).then(() => {
// If I check whether the table is expanded, the answer should be yes // If I check whether the table is expanded, the answer should be yes
let tableNode = find(childNodes, node => node.nodePath === table1NodePath); const tableNode = find(childNodes, node => node.nodePath === table1NodePath);
tableNode.isExpanded().then(isExpanded => { tableNode.isExpanded().then(isExpanded => {
try { try {
assert.equal(isExpanded, false); assert.equal(isExpanded, false);
@@ -622,9 +552,9 @@ suite('SQL Object Explorer Service tests', () => {
}, err => done(err)); }, err => done(err));
}); });
test('setting a node to expanded calls expand on the requested tree node', (done) => { test('setting a node to expanded calls expand on the requested tree node', async () => {
let table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath; const table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath;
let tableExpandInfo = { const tableExpandInfo = {
sessionId: sessionId, sessionId: sessionId,
nodes: [], nodes: [],
errorMessage: '', errorMessage: '',
@@ -643,97 +573,60 @@ suite('SQL Object Explorer Service tests', () => {
}); });
serverTreeView.setup(x => x.reveal(TypeMoq.It.isAny())).returns(() => Promise.resolve()); serverTreeView.setup(x => x.reveal(TypeMoq.It.isAny())).returns(() => Promise.resolve());
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
// If I expand the node, then it should get revealed and expanded // If I expand the node, then it should get revealed and expanded
objectExplorerService.getTreeNode(connection.id, table1NodePath).then(tableNode => { const tableNode = await objectExplorerService.getTreeNode(connection.id, table1NodePath);
tableNode.setExpandedState(TreeItemCollapsibleState.Expanded).then(() => { await tableNode.setExpandedState(TreeItemCollapsibleState.Expanded);
try { serverTreeView.verify(x => x.setExpandedState(TypeMoq.It.isValue(tableNode), TypeMoq.It.is(state => state === TreeItemCollapsibleState.Expanded)), TypeMoq.Times.once());
serverTreeView.verify(x => x.setExpandedState(TypeMoq.It.isValue(tableNode), TypeMoq.It.is(state => state === TreeItemCollapsibleState.Expanded)), TypeMoq.Times.once()); serverTreeView.verify(x => x.reveal(TypeMoq.It.isValue(tableNode)), TypeMoq.Times.once());
serverTreeView.verify(x => x.reveal(TypeMoq.It.isValue(tableNode)), TypeMoq.Times.once());
done();
} catch (err) {
done(err);
}
}, err => done(err));
}, err => done(err));
});
}); });
test('setting a node to collapsed calls collapse on the requested tree node', (done) => { test('setting a node to collapsed calls collapse on the requested tree node', async () => {
serverTreeView.setup(x => x.isExpanded(TypeMoq.It.isAny())).returns(treeNode => { serverTreeView.setup(x => x.isExpanded(TypeMoq.It.isAny())).returns(treeNode => {
return treeNode === connection; return treeNode === connection;
}); });
serverTreeView.setup(x => x.setExpandedState(TypeMoq.It.is(treeNode => treeNode === connection), TypeMoq.It.is(state => state === TreeItemCollapsibleState.Collapsed))).returns(() => Promise.resolve()); serverTreeView.setup(x => x.setExpandedState(TypeMoq.It.is(treeNode => treeNode === connection), TypeMoq.It.is(state => state === TreeItemCollapsibleState.Collapsed))).returns(() => Promise.resolve());
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection)).then(childNodes => { await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection));
// If I collapse the connection node, then the tree's collapse method should get called // If I collapse the connection node, then the tree's collapse method should get called
objectExplorerService.getTreeNode(connection.id, undefined).then(treeNode => treeNode.setExpandedState(TreeItemCollapsibleState.Collapsed).then(() => { const treeNode = await objectExplorerService.getTreeNode(connection.id, undefined);
try { await treeNode.setExpandedState(TreeItemCollapsibleState.Collapsed);
serverTreeView.verify(x => x.setExpandedState(TypeMoq.It.is(treeNode => treeNode === connection), TypeMoq.It.is(state => state === TreeItemCollapsibleState.Collapsed)), TypeMoq.Times.once()); serverTreeView.verify(x => x.setExpandedState(TypeMoq.It.is(treeNode => treeNode === connection), TypeMoq.It.is(state => state === TreeItemCollapsibleState.Collapsed)), TypeMoq.Times.once());
done();
} catch (err) {
done(err);
}
}, err => done(err)));
}, err => done(err));
}, err => done(err));
}); });
test('setNodeSelected sets the tree selection to the requested tree node', (done) => { test('setNodeSelected sets the tree selection to the requested tree node', async () => {
let table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath; const table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath;
serverTreeView.setup(x => x.setSelected(TypeMoq.It.is((treeNode: TreeNode) => treeNode.nodePath === table1NodePath), TypeMoq.It.isAny(), undefined)).returns(() => Promise.resolve()); serverTreeView.setup(x => x.setSelected(TypeMoq.It.is((treeNode: TreeNode) => treeNode.nodePath === table1NodePath), TypeMoq.It.isAny(), undefined)).returns(() => Promise.resolve());
serverTreeView.setup(x => x.reveal(TypeMoq.It.isAny())).returns(() => Promise.resolve()); serverTreeView.setup(x => x.reveal(TypeMoq.It.isAny())).returns(() => Promise.resolve());
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
// If I select the table node, then it should be selected and revealed // If I select the table node, then it should be selected and revealed
objectExplorerService.getTreeNode(connection.id, table1NodePath).then(tableNode => { const tableNode = await objectExplorerService.getTreeNode(connection.id, table1NodePath);
tableNode.setSelected(true).then(() => { await tableNode.setSelected(true);
try { serverTreeView.verify(x => x.setSelected(TypeMoq.It.isValue(tableNode), TypeMoq.It.isValue(true), undefined), TypeMoq.Times.once());
serverTreeView.verify(x => x.setSelected(TypeMoq.It.isValue(tableNode), TypeMoq.It.isValue(true), undefined), TypeMoq.Times.once()); serverTreeView.verify(x => x.reveal(TypeMoq.It.isValue(tableNode)), TypeMoq.Times.once());
serverTreeView.verify(x => x.reveal(TypeMoq.It.isValue(tableNode)), TypeMoq.Times.once());
done();
} catch (err) {
done(err);
}
}, err => done(err));
}, err => done(err));
}, err => done(err));
}); });
test('findTreeNode returns the tree node for the relevant node', (done) => { test('findTreeNode returns the tree node for the relevant node', async () => {
let table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath; const table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath;
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.getTreeNode(connection.id, table1NodePath).then(treeNode => { const treeNode = await objectExplorerService.getTreeNode(connection.id, table1NodePath);
try { assert.equal(treeNode.nodePath, objectExplorerExpandInfo.nodes[0].nodePath);
assert.equal(treeNode.nodePath, objectExplorerExpandInfo.nodes[0].nodePath); assert.equal(treeNode.nodeTypeId, objectExplorerExpandInfo.nodes[0].nodeType);
assert.equal(treeNode.nodeTypeId, objectExplorerExpandInfo.nodes[0].nodeType); assert.equal(treeNode.label, objectExplorerExpandInfo.nodes[0].label);
assert.equal(treeNode.label, objectExplorerExpandInfo.nodes[0].label);
done();
} catch (err) {
done(err);
}
}, err => done(err));
});
}); });
test('findTreeNode returns undefined if the requested node does not exist', (done) => { test('findTreeNode returns undefined if the requested node does not exist', async () => {
let invalidNodePath = objectExplorerSession.rootNode.nodePath + '/invalidNode'; const invalidNodePath = objectExplorerSession.rootNode.nodePath + '/invalidNode';
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => { await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.getTreeNode(connection.id, invalidNodePath).then(nodeInfo => { const nodeInfo = await objectExplorerService.getTreeNode(connection.id, invalidNodePath);
try { assert.equal(nodeInfo, undefined);
assert.equal(nodeInfo, undefined);
done();
} catch (err) {
done(err);
}
}, err => done(err));
});
}); });
test('refreshInView refreshes the node, expands it, and returns the refreshed node', async () => { test('refreshInView refreshes the node, expands it, and returns the refreshed node', async () => {
@@ -744,8 +637,8 @@ suite('SQL Object Explorer Service tests', () => {
objectExplorerService.registerServerTreeView(serverTreeView.object); objectExplorerService.registerServerTreeView(serverTreeView.object);
// Refresh the node // Refresh the node
let nodePath = objectExplorerSession.rootNode.nodePath; const nodePath = objectExplorerSession.rootNode.nodePath;
let refreshedNode = await objectExplorerService.refreshNodeInView(connection.id, nodePath); const refreshedNode = await objectExplorerService.refreshNodeInView(connection.id, nodePath);
// Verify that it was refreshed, expanded, and the refreshed detailed were returned // Verify that it was refreshed, expanded, and the refreshed detailed were returned
sqlOEProvider.verify(x => x.refreshNode(TypeMoq.It.is(refreshNode => refreshNode.nodePath === nodePath)), TypeMoq.Times.once()); sqlOEProvider.verify(x => x.refreshNode(TypeMoq.It.is(refreshNode => refreshNode.nodePath === nodePath)), TypeMoq.Times.once());
@@ -760,17 +653,17 @@ suite('SQL Object Explorer Service tests', () => {
await objectExplorerService.createNewSession(mssqlProviderName, connection); await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
// Set up the provider to not respond to the second expand request, simulating a request that takes a long time to complete // Set up the provider to not respond to the second expand request, simulating a request that takes a long time to compconste
const nodePath = objectExplorerSession.rootNode.nodePath; const nodePath = objectExplorerSession.rootNode.nodePath;
sqlOEProvider.setup(x => x.expandNode(TypeMoq.It.is(x => x.nodePath === nodePath))).callback(() => { }).returns(() => Promise.resolve(true)); sqlOEProvider.setup(x => x.expandNode(TypeMoq.It.is(x => x.nodePath === nodePath))).callback(() => { }).returns(() => Promise.resolve(true));
// If I queue a second expand request (the first completes normally because of the original mock) and then close the session // If I queue a second expand request (the first compconstes normally because of the original mock) and then close the session
await objectExplorerService.expandNode(mssqlProviderName, objectExplorerSession, objectExplorerSession.rootNode.nodePath); await objectExplorerService.expandNode(mssqlProviderName, objectExplorerSession, objectExplorerSession.rootNode.nodePath);
let expandPromise = objectExplorerService.expandNode(mssqlProviderName, objectExplorerSession, objectExplorerSession.rootNode.nodePath); const expandPromise = objectExplorerService.expandNode(mssqlProviderName, objectExplorerSession, objectExplorerSession.rootNode.nodePath);
let closeSessionResult = await objectExplorerService.closeSession(mssqlProviderName, objectExplorerSession); const closeSessionResult = await objectExplorerService.closeSession(mssqlProviderName, objectExplorerSession);
// Then the expand request has completed and the session is closed // Then the expand request has compconsted and the session is closed
let expandResult = await expandPromise; const expandResult = await expandPromise;
assert.equal(expandResult.nodes.length, 0); assert.equal(expandResult.nodes.length, 0);
assert.equal(closeSessionResult.success, true); assert.equal(closeSessionResult.success, true);
}); });
@@ -780,8 +673,8 @@ suite('SQL Object Explorer Service tests', () => {
objectExplorerService.onSessionCreated(1, objectExplorerSession); objectExplorerService.onSessionCreated(1, objectExplorerSession);
// If I call resolveTreeNodeChildren once, set an error on the node, and then call it again // If I call resolveTreeNodeChildren once, set an error on the node, and then call it again
let tablesNodePath = 'testServerName/tables'; const tablesNodePath = 'testServerName/tables';
let tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, tablesNodePath, '', '', null, null, undefined, undefined); const tablesNode = new TreeNode(NodeType.Folder, 'Tables', false, tablesNodePath, '', '', null, null, undefined, undefined);
tablesNode.connection = connection; tablesNode.connection = connection;
await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, tablesNode); await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, tablesNode);
sqlOEProvider.verify(x => x.refreshNode(TypeMoq.It.is(x => x.nodePath === tablesNodePath)), TypeMoq.Times.never()); sqlOEProvider.verify(x => x.refreshNode(TypeMoq.It.is(x => x.nodePath === tablesNodePath)), TypeMoq.Times.never());

2
src/sql/workbench/services/profiler/browser/interfaces.ts
View File

@@ -139,7 +139,7 @@ export interface IProfilerService {
* Saves the filter * Saves the filter
* @param filter filter object * @param filter filter object
*/ */
saveFilter(filter: ProfilerFilter): void; saveFilter(filter: ProfilerFilter): Promise<void>;
} }
export interface IProfilerSettings { export interface IProfilerSettings {

4
src/sql/workbench/services/profiler/browser/profilerService.ts
View File

@@ -245,8 +245,8 @@ export class ProfilerService implements IProfilerService {
return config; return config;
} }
public saveFilter(filter: ProfilerFilter): void { public async saveFilter(filter: ProfilerFilter): Promise<void> {
const config = [filter]; const config = [filter];
this._configurationService.updateValue(PROFILER_FILTER_SETTINGS, config, ConfigurationTarget.USER); await this._configurationService.updateValue(PROFILER_FILTER_SETTINGS, config, ConfigurationTarget.USER);
} }
} }

42
src/sql/workbench/services/resourceProvider/browser/resourceProviderService.ts
View File

@@ -64,34 +64,24 @@ export class ResourceProviderService implements IResourceProviderService {
/** /**
* Handle a firewall rule * Handle a firewall rule
*/ */
public handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Promise<IHandleFirewallRuleResult> { public async handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Promise<IHandleFirewallRuleResult> {
let self = this; let handleFirewallRuleResult: IHandleFirewallRuleResult = { canHandleFirewallRule: false, ipAddress: undefined, resourceProviderId: undefined };
return new Promise<IHandleFirewallRuleResult>((resolve, reject) => { const promises = [];
let handleFirewallRuleResult: IHandleFirewallRuleResult; if (this._providers) {
let promises = []; for (const key in this._providers) {
if (self._providers) { const provider = this._providers[key];
for (let key in self._providers) { promises.push(provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId)
let provider = self._providers[key]; .then(response => {
promises.push(provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId) if (response.result) {
.then(response => { handleFirewallRuleResult = { canHandleFirewallRule: response.result, ipAddress: response.ipAddress, resourceProviderId: key };
if (response.result) { }
handleFirewallRuleResult = { canHandleFirewallRule: response.result, ipAddress: response.ipAddress, resourceProviderId: key }; }, () => { /* Swallow failures at getting accounts, we'll just hide that provider */
} }));
},
() => { /* Swallow failures at getting accounts, we'll just hide that provider */
}));
}
} }
}
Promise.all(promises).then(() => { await Promise.all(promises);
if (handleFirewallRuleResult) { return handleFirewallRuleResult;
resolve(handleFirewallRuleResult);
} else {
handleFirewallRuleResult = { canHandleFirewallRule: false, ipAddress: undefined, resourceProviderId: undefined };
resolve(handleFirewallRuleResult);
}
});
});
} }
/** /**