ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-01-13 17:22:15 -05:00
Code Issues Packages Projects Releases Wiki Activity

Properly expose errors in ads and tests (#8692)

Browse Source 
* add code to expose errors outside zone

* remove unexpect error hiding

* remove uncessary code

* fix tests

* trying to catch more errros

* revert for testing

* wip

* wip

* figured out what was going on

* wip

* fix tests

* fix tests
This commit is contained in:
Anthony Dresser
2019-12-17 12:06:36 -08:00
committed by GitHub
parent 6b5c31410d
commit ea5f9be441
29 changed files with 483 additions and 790 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/sql/base/test/common/async.ts
View File

@@ -1,19 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
export async function assertThrowsAsync(fn: () => Promise<any>, expectedMessage?: string): Promise<void> {
let threw = false;
try {
await fn();
} catch (e) {
threw = true;
if (expectedMessage) {
assert.strictEqual(e.message, expectedMessage);
}
}
assert.equal(threw, true, 'Expected function to throw but it did not');
}

3
src/sql/platform/accounts/common/accountViewModel.ts
View File

@@ -7,6 +7,7 @@ import * as azdata from 'azdata';
import { Event, Emitter } from 'vs/base/common/event';
import { IAccountManagementService } from 'sql/platform/accounts/common/interfaces';
import { AccountProviderAddedEventParams, UpdateAccountListEventParams } from 'sql/platform/accounts/common/eventTypes';
import { coalesce } from 'vs/base/common/arrays';
/**
* View model for account dialog
@@ -57,7 +58,7 @@ export class AccountViewModel {
},
() => { /* Swallow failures at getting accounts, we'll just hide that provider */ });
});
return Promise.all(promises);
return Promise.all(promises).then(accounts => coalesce(accounts));
}, () => {
/* Swallow failures and just pretend we don't have any providers */
return [];

19
src/sql/platform/accounts/test/common/accountPickerViewModel.test.ts
View File

@@ -71,14 +71,14 @@ suite('Account picker view model tests', () => {
evUpdateAccounts.assertFired(argUpdateAccounts);
});
test('Initialize - Success', done => {
test('Initialize - Success', () => {
// Setup: Create a viewmodel with event handlers
let mockAccountManagementService = getMockAccountManagementService(true, true);
let evUpdateAccounts = new EventVerifierSingle<UpdateAccountListEventParams>();
let vm = getViewModel(mockAccountManagementService.object, evUpdateAccounts);
// If: I initialize the view model
vm.initialize()
return vm.initialize()
.then(results => {
// Then:
// ... None of the events should have fired
@@ -91,20 +91,17 @@ suite('Account picker view model tests', () => {
assert.ok(Array.isArray(results));
assert.equal(results.length, 2);
assert.equal(results, accounts);
}).then(
() => done(),
err => done(err)
);
});
});
test('Initialize - Get accounts fails expects empty array', done => {
test('Initialize - Get accounts fails expects empty array', () => {
// Setup: Create a mock account management service that rejects the promise
let mockAccountManagementService = getMockAccountManagementService(true, false);
let evUpdateAccounts = new EventVerifierSingle<UpdateAccountListEventParams>();
let vm = getViewModel(mockAccountManagementService.object, evUpdateAccounts);
// If: I initialize the view model
vm.initialize()
return vm.initialize()
.then(result => {
// Then:
// ... None of the events should have fired
@@ -116,11 +113,7 @@ suite('Account picker view model tests', () => {
// ... The results should be an empty array
assert.ok(Array.isArray(result));
assert.equal(result.length, 0);
assert.equal(result, []);
}).then(
() => done(),
err => done()
);
});
});
});

160
src/sql/platform/accounts/test/common/accountStore.test.ts
View File

@@ -9,13 +9,13 @@ import AccountStore from 'sql/platform/accounts/common/accountStore';
import { EventVerifierSingle } from 'sql/base/test/common/event';
suite('Account Store Tests', () => {
test('AddOrUpdate - Uninitialized memento', done => {
test('AddOrUpdate - Uninitialized memento', () => {
// Setup: Create account store w/o initialized memento
let memento = {};
let as = new AccountStore(memento);
// If: I add an account to the store
as.addOrUpdate(account1)
return as.addOrUpdate(account1)
.then(result => {
// Then:
// ... I should have gotten back a result indicating the account was added
@@ -27,21 +27,17 @@ suite('Account Store Tests', () => {
assert.ok(Array.isArray(memento[AccountStore.MEMENTO_KEY]));
assert.equal(memento[AccountStore.MEMENTO_KEY].length, 1);
assertAccountEqual(memento[AccountStore.MEMENTO_KEY][0], account1);
})
.then(
() => done(),
e => done(e)
);
});
});
test('AddOrUpdate - Adds to accounts', done => {
test('AddOrUpdate - Adds to accounts', () => {
// Setup: Create account store with initialized memento with accounts
let memento = {};
memento[AccountStore.MEMENTO_KEY] = [];
let as = new AccountStore(memento);
// If: I add an account to the store
as.addOrUpdate(account1)
return as.addOrUpdate(account1)
.then(result => {
// Then:
// ... I should have gotten back a result indicating the account was added
@@ -53,14 +49,10 @@ suite('Account Store Tests', () => {
assert.ok(Array.isArray(memento[AccountStore.MEMENTO_KEY]));
assert.equal(memento[AccountStore.MEMENTO_KEY].length, 1);
assertAccountEqual(memento[AccountStore.MEMENTO_KEY][0], account1);
})
.then(
() => done(),
e => done(e)
);
});
});
test('AddOrUpdate - Updates account', done => {
test('AddOrUpdate - Updates account', () => {
// Setup: Create account store with initialized memento with accounts
let memento = getTestMemento();
let as = new AccountStore(memento);
@@ -71,7 +63,7 @@ suite('Account Store Tests', () => {
displayInfo: account1.displayInfo,
isStale: account1.isStale
};
as.addOrUpdate(param)
return as.addOrUpdate(param)
.then(result => {
// Then:
// ... I should have gotten back a result indicating the account was updated
@@ -84,20 +76,16 @@ suite('Account Store Tests', () => {
assert.equal(memento[AccountStore.MEMENTO_KEY].length, 2);
assertAccountEqual(memento[AccountStore.MEMENTO_KEY][0], account1);
assertAccountEqual(memento[AccountStore.MEMENTO_KEY][1], param);
})
.then(
() => done(),
e => done(e)
);
});
});
test('GetAccountsByProvider - Uninitialized memento', done => {
test('GetAccountsByProvider - Uninitialized memento', () => {
// Setup: Create account store w/o initialized memento
let memento = {};
let as = new AccountStore(memento);
// If: I get accounts by provider
as.getAccountsByProvider('azure')
return as.getAccountsByProvider('azure')
.then(result => {
// Then:
// ... I should get back an empty array
@@ -106,77 +94,61 @@ suite('Account Store Tests', () => {
// ... Memento should not have been written
assert.equal(Object.keys(memento).length, 0);
})
.then(
() => done(),
e => done(e)
);
});
});
test('GetAccountsByProvider - No accounts', done => {
test('GetAccountsByProvider - No accounts', () => {
// Setup: Create account store with initialized memento with accounts
let memento = {};
memento[AccountStore.MEMENTO_KEY] = [];
let as = new AccountStore(memento);
// If: I get accounts when there aren't any accounts
as.getAccountsByProvider('azure')
return as.getAccountsByProvider('azure')
.then(result => {
// Then: I should get back an empty array
assert.ok(Array.isArray(result));
assert.equal(result.length, 0);
})
.then(
() => done(),
e => done(e)
);
});
});
test('GetAccountsByProvider - Accounts, but no accounts for provider', done => {
test('GetAccountsByProvider - Accounts, but no accounts for provider', () => {
// Setup: Create account store with initialized memento with accounts
let memento = getTestMemento();
let as = new AccountStore(memento);
// If: I get accounts by provider that doesn't have accounts
as.getAccountsByProvider('cloudycloud')
return as.getAccountsByProvider('cloudycloud')
.then(result => {
// Then: I should get back an empty array
assert.ok(Array.isArray(result));
assert.equal(result.length, 0);
})
.then(
() => done(),
e => done(e)
);
});
});
test('GetAccountsByProvider - Accounts for provider', done => {
test('GetAccountsByProvider - Accounts for provider', () => {
// Setup: Create account store with initialized memento with accounts
let memento = getTestMemento();
let as = new AccountStore(memento);
// If: I get accounts by provider that has accounts
as.getAccountsByProvider('azure')
return as.getAccountsByProvider('azure')
.then(result => {
// Then: I should get the accounts
assert.ok(Array.isArray(result));
assert.equal(result.length, 2);
assertAccountEqual(result[0], memento[AccountStore.MEMENTO_KEY][0]);
assertAccountEqual(result[1], memento[AccountStore.MEMENTO_KEY][1]);
})
.then(
() => done(),
e => done(e)
);
});
});
test('GetAllAccounts - Uninitialized memento', done => {
test('GetAllAccounts - Uninitialized memento', () => {
// Setup: Create account store w/o initialized memento
let memento = {};
let as = new AccountStore(memento);
// If: I get accounts
as.getAllAccounts()
return as.getAllAccounts()
.then(result => {
// Then:
// ... I should get back an empty array
@@ -185,59 +157,47 @@ suite('Account Store Tests', () => {
// ... Memento should not have been written
assert.equal(Object.keys(memento).length, 0);
})
.then(
() => done(),
e => done(e)
);
});
});
test('GetAllAccounts - No accounts', done => {
test('GetAllAccounts - No accounts', () => {
// Setup: Create account store with initialized memento with accounts
let memento = {};
memento[AccountStore.MEMENTO_KEY] = [];
let as = new AccountStore(memento);
// If: I get accounts when there aren't any accounts
as.getAllAccounts()
return as.getAllAccounts()
.then(result => {
// Then: I should get back an empty array
assert.ok(Array.isArray(result));
assert.equal(result.length, 0);
})
.then(
() => done(),
e => done(e)
);
});
});
test('GetAllAccounts - Accounts', done => {
test('GetAllAccounts - Accounts', () => {
// Setup: Create account store with initialized memento with accounts
let memento = getTestMemento();
let as = new AccountStore(memento);
// If: I get accounts
as.getAllAccounts()
return as.getAllAccounts()
.then(result => {
// Then: I should get the accounts
assert.ok(Array.isArray(result));
assert.equal(result.length, 2);
assertAccountEqual(result[0], memento[AccountStore.MEMENTO_KEY][0]);
assertAccountEqual(result[1], memento[AccountStore.MEMENTO_KEY][1]);
})
.then(
() => done(),
e => done(e)
);
});
});
test('Remove - Uninitialized menento', done => {
test('Remove - Uninitialized menento', () => {
// Setup: Create account store w/o initialized memento
let memento = {};
let as = new AccountStore(memento);
// If: I remove an account when there's an uninitialized memento
as.remove(account1.key)
return as.remove(account1.key)
.then(result => {
// Then:
// ... I should get back false (no account removed)
@@ -246,21 +206,17 @@ suite('Account Store Tests', () => {
// ... The memento should have been initialized
assert.ok(Array.isArray(memento[AccountStore.MEMENTO_KEY]));
assert.equal(memento[AccountStore.MEMENTO_KEY].length, 0);
})
.then(
() => done(),
e => done(e)
);
});
});
test('Remove - Account does not exist', done => {
test('Remove - Account does not exist', () => {
// Setup: Create account store with initialized memento with accounts
let memento = {};
memento[AccountStore.MEMENTO_KEY] = [];
let as = new AccountStore(memento);
// If: I remove an account that doesn't exist
as.remove({ providerId: 'cloudyCloud', accountId: 'testyTest' })
return as.remove({ providerId: 'cloudyCloud', accountId: 'testyTest' })
.then(result => {
// Then:
// ... I should get back false (no account removed)
@@ -269,20 +225,16 @@ suite('Account Store Tests', () => {
// ... The memento should still be empty
assert.ok(Array.isArray(memento[AccountStore.MEMENTO_KEY]));
assert.equal(memento[AccountStore.MEMENTO_KEY].length, 0);
})
.then(
() => done(),
e => done(e)
);
});
});
test('Remove - Account exists', done => {
test('Remove - Account exists', () => {
// Setup: Create account store with initialized memento with accounts
let memento = getTestMemento();
let as = new AccountStore(memento);
// If: I remove an account that does exist
as.remove(account1.key)
return as.remove(account1.key)
.then(result => {
// Then:
// ... I should get back true (account removed)
@@ -292,14 +244,10 @@ suite('Account Store Tests', () => {
assert.ok(Array.isArray(memento[AccountStore.MEMENTO_KEY]));
assert.equal(memento[AccountStore.MEMENTO_KEY].length, 1);
assertAccountEqual(memento[AccountStore.MEMENTO_KEY][0], account2);
})
.then(
() => done(),
e => done(e)
);
});
});
test('Update - Uninitialized menento', done => {
test('Update - Uninitialized menento', () => {
// Setup:
// ... Create account store w/o initialized memento
let memento = {};
@@ -309,7 +257,7 @@ suite('Account Store Tests', () => {
let updateCallback = new EventVerifierSingle<azdata.Account>();
// If: I update an account
as.update(account1.key, updateCallback.eventHandler)
return as.update(account1.key, updateCallback.eventHandler)
.then(result => {
// Then:
// ... I should get back false (account did not change)
@@ -321,14 +269,10 @@ suite('Account Store Tests', () => {
// ... The callback shouldn't have been called
updateCallback.assertNotFired();
})
.then(
() => done(),
e => done(e)
);
});
});
test('Update - Account does not exist', done => {
test('Update - Account does not exist', () => {
// Setup: Create account store with initialized memento with accounts
let memento = {};
memento[AccountStore.MEMENTO_KEY] = [];
@@ -338,7 +282,7 @@ suite('Account Store Tests', () => {
let updateCallback = new EventVerifierSingle<azdata.Account>();
// If: I update an account that doesn't exist
as.update({ accountId: 'testyTest', providerId: 'cloudyCloud' }, updateCallback.eventHandler)
return as.update({ accountId: 'testyTest', providerId: 'cloudyCloud' }, updateCallback.eventHandler)
.then(result => {
// Then:
// ... I should get back false (account did not change)
@@ -350,14 +294,10 @@ suite('Account Store Tests', () => {
// ... The callback shouldn't have been called
updateCallback.assertNotFired();
})
.then(
() => done(),
e => done(e)
);
});
});
test('Update - Account exists', done => {
test('Update - Account exists', () => {
// Setup: Create account store with initialized memento with accounts
let memento = getTestMemento();
let as = new AccountStore(memento);
@@ -369,7 +309,7 @@ suite('Account Store Tests', () => {
};
// If: I update an account that exists
as.update(account1.key, updateCallback)
return as.update(account1.key, updateCallback)
.then(result => {
// Then:
// ... I should get back true (account did change)
@@ -384,11 +324,7 @@ suite('Account Store Tests', () => {
// ... Account 2 should have stayed the same
assertAccountEqual(memento[AccountStore.MEMENTO_KEY][1], account2);
})
.then(
() => done(),
e => done(e)
);
});
});
// TODO: Test to make sure operations occur sequentially

28
src/sql/platform/accounts/test/common/accountViewModel.test.ts
View File

@@ -91,7 +91,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
evUpdateAccounts.assertFired(argUpdateAccounts);
});
test('Initialize - Success', done => {
test('Initialize - Success', () => {
// Setup: Create a viewmodel with event handlers
let mockAccountManagementService = getMockAccountManagementService(true, true);
let evAddProvider = new EventVerifierSingle<AccountProviderAddedEventParams>();
@@ -100,7 +100,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
let vm = getViewModel(mockAccountManagementService.object, evAddProvider, evRemoveProvider, evUpdateAccounts);
// If: I initialize the view model
vm.initialize()
return vm.initialize()
.then(results => {
// Then:
// ... None of the events should have fired
@@ -115,13 +115,10 @@ suite('Account Management Dialog ViewModel Tests', () => {
assert.equal(results.length, 1);
assert.equal(results[0].addedProvider, providers[0]);
assert.equal(results[0].initialAccounts, accounts);
}).then(
() => done(),
err => done(err)
);
});
});
test('Initialize - Get providers fails', done => {
test('Initialize - Get providers fails', () => {
// Setup: Create a mock account management service that rejects looking up providers
let mockAccountManagementService = getMockAccountManagementService(false, true);
let evAddProvider = new EventVerifierSingle<AccountProviderAddedEventParams>();
@@ -130,7 +127,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
let vm = getViewModel(mockAccountManagementService.object, evAddProvider, evRemoveProvider, evUpdateAccounts);
// If: I initialize the view model
vm.initialize()
return vm.initialize()
.then(results => {
// Then
// ... None of the events should have fired
@@ -143,14 +140,10 @@ suite('Account Management Dialog ViewModel Tests', () => {
// ... The results that were returned should be an empty array
assert.ok(Array.isArray(results));
assert.equal(results.length, 0);
})
.then(
() => done(),
err => done(err)
);
});
});
test('Initialize - Get accounts fails', done => {
test.skip('Initialize - Get accounts fails', () => { // @anthonydresser I don't understand this test, it says get accounts fails, but then assumes there will be accounts in the results...
// Setup: Create a mock account management service that rejects the promise
let mockAccountManagementService = getMockAccountManagementService(true, false);
let evAddProvider = new EventVerifierSingle<AccountProviderAddedEventParams>();
@@ -159,7 +152,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
let vm = getViewModel(mockAccountManagementService.object, evAddProvider, evRemoveProvider, evUpdateAccounts);
// If: I initialize the view model
vm.initialize()
return vm.initialize()
.then(result => {
// Then:
// ... None of the events should have fired
@@ -174,10 +167,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
assert.equal(result.length, 1);
assert.equal(result[0].addedProvider, providers[0]);
assert.equal(result[0].initialAccounts, accounts);
}).then(
() => done(),
err => done()
);
});
});
});

2
src/sql/platform/credentials/test/common/testCredentialsService.ts
View File

@@ -37,7 +37,7 @@ export class TestCredentialsService implements ICredentialsService {
}
addEventListener(handle: number, events: CredentialManagementEvents): IDisposable {
throw new Error('Method not implemented.');
return { dispose: () => { } };
}
}

92
src/sql/platform/jobManagement/test/electron-browser/jobActions.test.ts
View File

@@ -74,9 +74,13 @@ suite('Job Management Actions', () => {
errorMessage: null
};
mockJobManagementService.setup(s => s.jobAction(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(resultStatus));
mockJobManagementService.setup(s => s.deleteJobStep(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(resultStatus));
mockJobManagementService.setup(s => s.deleteProxy(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(resultStatus));
mockJobManagementService.setup(s => s.deleteOperator(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(resultStatus));
mockJobManagementService.setup(s => s.deleteAlert(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(resultStatus));
});
test('Jobs Refresh Action', (done) => {
test('Jobs Refresh Action', async () => {
mockRefreshAction = TypeMoq.Mock.ofType(JobsRefreshAction, TypeMoq.MockBehavior.Strict, JobsRefreshAction.ID, JobsRefreshAction.LABEL);
mockRefreshAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => mockJobsViewComponent.object.refreshJobs());
mockRefreshAction.setup(s => s.id).returns(() => JobsRefreshAction.ID);
@@ -85,12 +89,11 @@ suite('Job Management Actions', () => {
assert.equal(mockRefreshAction.object.label, JobsRefreshAction.LABEL);
// Job Refresh Action from Jobs View should refresh the component
mockRefreshAction.object.run(null);
await mockRefreshAction.object.run(null);
mockJobsViewComponent.verify(c => c.refreshJobs(), TypeMoq.Times.once());
done();
});
test('New Job Action', (done) => {
test('New Job Action', async () => {
mockNewJobAction = TypeMoq.Mock.ofType(NewJobAction, TypeMoq.MockBehavior.Strict, NewJobAction.ID, NewJobAction.LABEL);
mockNewJobAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => mockJobsViewComponent.object.openCreateJobDialog());
mockNewJobAction.setup(s => s.id).returns(() => NewJobAction.ID);
@@ -99,12 +102,11 @@ suite('Job Management Actions', () => {
assert.equal(mockNewJobAction.object.label, NewJobAction.LABEL);
// New Job Action from Jobs View should open a dialog
mockNewJobAction.object.run(null);
await mockNewJobAction.object.run(null);
mockJobsViewComponent.verify(c => c.openCreateJobDialog(), TypeMoq.Times.once());
done();
});
test('Edit Job Action', (done) => {
test('Edit Job Action', async () => {
mockEditJobAction = TypeMoq.Mock.ofType(EditJobAction, TypeMoq.MockBehavior.Strict, EditJobAction.ID, EditJobAction.LABEL);
let commandServiceCalled: boolean = false;
mockEditJobAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => {
@@ -117,12 +119,11 @@ suite('Job Management Actions', () => {
assert.equal(mockEditJobAction.object.label, EditJobAction.LABEL);
// Edit Job Action from Jobs View should open a dialog
mockEditJobAction.object.run(null);
await mockEditJobAction.object.run(null);
assert(commandServiceCalled);
done();
});
test('Run Job Action', (done) => {
test('Run Job Action', async () => {
mockRunJobAction = TypeMoq.Mock.ofType(RunJobAction, TypeMoq.MockBehavior.Strict, RunJobAction.ID, RunJobAction.LABEL, null, null, mockJobManagementService);
mockRunJobAction.setup(s => s.run(TypeMoq.It.isAny())).returns(async () => {
let result = await mockJobManagementService.object.jobAction(null, null, null).then((result) => result.success);
@@ -135,12 +136,11 @@ suite('Job Management Actions', () => {
assert.equal(mockRunJobAction.object.label, RunJobAction.LABEL);
// Run Job Action should make the Job Management service call job action
mockRunJobAction.object.run(null);
await mockRunJobAction.object.run(null);
mockJobManagementService.verify(s => s.jobAction(null, null, null), TypeMoq.Times.once());
done();
});
test('Stop Job Action', (done) => {
test('Stop Job Action', async () => {
mockStopJobAction = TypeMoq.Mock.ofType(StopJobAction, TypeMoq.MockBehavior.Strict, StopJobAction.ID, StopJobAction.LABEL, null, null, mockJobManagementService);
mockStopJobAction.setup(s => s.run(TypeMoq.It.isAny())).returns(async () => {
let result = await mockJobManagementService.object.jobAction(null, null, null).then((result) => result.success);
@@ -153,12 +153,11 @@ suite('Job Management Actions', () => {
assert.equal(mockStopJobAction.object.label, RunJobAction.LABEL);
// Run Job Action should make the Job Management service call job action
mockStopJobAction.object.run(null);
await mockStopJobAction.object.run(null);
mockJobManagementService.verify(s => s.jobAction(null, null, null), TypeMoq.Times.once());
done();
});
test('Delete Job Action', (done) => {
test('Delete Job Action', async () => {
mockDeleteJobAction = TypeMoq.Mock.ofType(DeleteJobAction, TypeMoq.MockBehavior.Strict, DeleteJobAction.ID, DeleteJobAction.LABEL, null, null, mockJobManagementService);
mockDeleteJobAction.setup(s => s.run(TypeMoq.It.isAny())).returns(async () => {
let result = await mockJobManagementService.object.jobAction(null, null, null).then((result) => result.success);
@@ -171,13 +170,12 @@ suite('Job Management Actions', () => {
assert.equal(mockDeleteJobAction.object.label, DeleteJobAction.LABEL);
// Run Job Action should make the Job Management service call job action
mockDeleteJobAction.object.run(null);
await mockDeleteJobAction.object.run(null);
mockJobManagementService.verify(s => s.jobAction(null, null, null), TypeMoq.Times.once());
done();
});
// Step Actions
test('New Step Action', (done) => {
test('New Step Action', async () => {
mockNewStepAction = TypeMoq.Mock.ofType(NewStepAction, TypeMoq.MockBehavior.Strict, NewJobAction.ID, NewJobAction.LABEL);
let commandServiceCalled = false;
mockNewStepAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => {
@@ -190,18 +188,17 @@ suite('Job Management Actions', () => {
assert.equal(mockNewStepAction.object.label, NewJobAction.LABEL);
// New Step Action should called command service
mockNewStepAction.object.run(null);
await mockNewStepAction.object.run(null);
assert(commandServiceCalled);
done();
});
test('Delete Step Action', (done) => {
test('Delete Step Action', async () => {
mockDeleteStepAction = TypeMoq.Mock.ofType(DeleteStepAction, TypeMoq.MockBehavior.Strict, DeleteStepAction.ID, DeleteStepAction.LABEL);
let commandServiceCalled = false;
mockDeleteStepAction.setup(s => s.run(TypeMoq.It.isAny())).returns(async () => {
commandServiceCalled = true;
await mockJobManagementService.object.deleteJobStep(null, null).then((result) => result.success);
return Promise.resolve(commandServiceCalled);
return commandServiceCalled;
});
mockDeleteStepAction.setup(s => s.id).returns(() => DeleteStepAction.ID);
mockDeleteStepAction.setup(s => s.label).returns(() => DeleteStepAction.LABEL);
@@ -209,14 +206,13 @@ suite('Job Management Actions', () => {
assert.equal(mockDeleteStepAction.object.label, DeleteStepAction.LABEL);
// Delete Step Action should called command service
mockDeleteStepAction.object.run(null);
await mockDeleteStepAction.object.run(null);
assert(commandServiceCalled);
mockJobManagementService.verify(s => s.deleteJobStep(null, null), TypeMoq.Times.once());
done();
});
// Alert Actions
test('New Alert Action', (done) => {
test('New Alert Action', async () => {
mockNewAlertAction = TypeMoq.Mock.ofType(NewJobAction, TypeMoq.MockBehavior.Strict, NewJobAction.ID, NewJobAction.LABEL);
mockNewAlertAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => mockAlertsViewComponent.object.openCreateAlertDialog());
mockNewAlertAction.setup(s => s.id).returns(() => NewJobAction.ID);
@@ -225,12 +221,11 @@ suite('Job Management Actions', () => {
assert.equal(mockNewAlertAction.object.label, NewJobAction.LABEL);
// New Alert Action from Alerts View should open a dialog
mockNewAlertAction.object.run(null);
await mockNewAlertAction.object.run(null);
mockAlertsViewComponent.verify(c => c.openCreateAlertDialog(), TypeMoq.Times.once());
done();
});
test('Edit Alert Action', (done) => {
test('Edit Alert Action', async () => {
mockEditAlertAction = TypeMoq.Mock.ofType(EditAlertAction, TypeMoq.MockBehavior.Strict, EditAlertAction.ID, EditAlertAction.LABEL);
let commandServiceCalled: boolean = false;
mockEditAlertAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => {
@@ -243,12 +238,11 @@ suite('Job Management Actions', () => {
assert.equal(mockEditAlertAction.object.label, EditAlertAction.LABEL);
// Edit Alert Action from Jobs View should open a dialog
mockEditAlertAction.object.run(null);
await mockEditAlertAction.object.run(null);
assert(commandServiceCalled);
done();
});
test('Delete Alert Action', (done) => {
test('Delete Alert Action', async () => {
mockDeleteAlertAction = TypeMoq.Mock.ofType(DeleteAlertAction, TypeMoq.MockBehavior.Strict, DeleteAlertAction.ID, DeleteAlertAction.LABEL, null, null, mockJobManagementService);
let commandServiceCalled = false;
mockDeleteAlertAction.setup(s => s.run(TypeMoq.It.isAny())).returns(async () => {
@@ -262,14 +256,13 @@ suite('Job Management Actions', () => {
assert.equal(mockDeleteAlertAction.object.label, DeleteAlertAction.LABEL);
// Delete Alert Action should call job management service
mockDeleteAlertAction.object.run(null);
await mockDeleteAlertAction.object.run(null);
assert(commandServiceCalled);
mockJobManagementService.verify(s => s.deleteAlert(null, null), TypeMoq.Times.once());
done();
});
// Operator Tests
test('New Operator Action', (done) => {
test('New Operator Action', async () => {
mockNewOperatorAction = TypeMoq.Mock.ofType(NewOperatorAction, TypeMoq.MockBehavior.Strict, NewOperatorAction.ID, NewOperatorAction.LABEL);
mockNewOperatorAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => mockOperatorsViewComponent.object.openCreateOperatorDialog());
mockNewOperatorAction.setup(s => s.id).returns(() => NewOperatorAction.ID);
@@ -278,12 +271,11 @@ suite('Job Management Actions', () => {
assert.equal(mockNewOperatorAction.object.label, NewOperatorAction.LABEL);
// New Operator Action from Operators View should open a dialog
mockNewOperatorAction.object.run(null);
await mockNewOperatorAction.object.run(null);
mockOperatorsViewComponent.verify(c => c.openCreateOperatorDialog(), TypeMoq.Times.once());
done();
});
test('Edit Operator Action', (done) => {
test('Edit Operator Action', async () => {
mockEditOperatorAction = TypeMoq.Mock.ofType(EditOperatorAction, TypeMoq.MockBehavior.Strict, EditOperatorAction.ID, EditOperatorAction.LABEL);
let commandServiceCalled: boolean = false;
mockEditOperatorAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => {
@@ -296,12 +288,11 @@ suite('Job Management Actions', () => {
assert.equal(mockEditOperatorAction.object.label, EditOperatorAction.LABEL);
// Edit Operator Action from Jobs View should open a dialog
mockEditOperatorAction.object.run(null);
await mockEditOperatorAction.object.run(null);
assert(commandServiceCalled);
done();
});
test('Delete Operator Action', (done) => {
test('Delete Operator Action', async () => {
mockDeleteOperatorAction = TypeMoq.Mock.ofType(DeleteOperatorAction, TypeMoq.MockBehavior.Strict, DeleteOperatorAction.ID, DeleteOperatorAction.LABEL, null, null, mockJobManagementService);
let commandServiceCalled = false;
mockDeleteOperatorAction.setup(s => s.run(TypeMoq.It.isAny())).returns(async () => {
@@ -315,14 +306,13 @@ suite('Job Management Actions', () => {
assert.equal(mockDeleteOperatorAction.object.label, DeleteOperatorAction.LABEL);
// Delete Operator Action should call job management service
mockDeleteOperatorAction.object.run(null);
await mockDeleteOperatorAction.object.run(null);
assert(commandServiceCalled);
mockJobManagementService.verify(s => s.deleteOperator(null, null), TypeMoq.Times.once());
done();
});
// Proxy Actions
test('New Proxy Action', (done) => {
test('New Proxy Action', async () => {
mockNewProxyAction = TypeMoq.Mock.ofType(NewProxyAction, TypeMoq.MockBehavior.Strict, NewProxyAction.ID, NewProxyAction.LABEL);
mockNewProxyAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => mockProxiesViewComponent.object.openCreateProxyDialog());
mockNewProxyAction.setup(s => s.id).returns(() => NewProxyAction.ID);
@@ -331,12 +321,11 @@ suite('Job Management Actions', () => {
assert.equal(mockNewProxyAction.object.label, NewProxyAction.LABEL);
// New Proxy Action from Alerts View should open a dialog
mockNewProxyAction.object.run(null);
await mockNewProxyAction.object.run(null);
mockProxiesViewComponent.verify(c => c.openCreateProxyDialog(), TypeMoq.Times.once());
done();
});
test('Edit Proxy Action', (done) => {
test('Edit Proxy Action', async () => {
mockEditProxyAction = TypeMoq.Mock.ofType(EditProxyAction, TypeMoq.MockBehavior.Strict, EditProxyAction.ID, EditProxyAction.LABEL);
let commandServiceCalled: boolean = false;
mockEditProxyAction.setup(s => s.run(TypeMoq.It.isAny())).returns(() => {
@@ -349,12 +338,11 @@ suite('Job Management Actions', () => {
assert.equal(mockEditProxyAction.object.label, EditProxyAction.LABEL);
// Edit Proxy Action from Proxies View should open a dialog
mockEditProxyAction.object.run(null);
await mockEditProxyAction.object.run(null);
assert(commandServiceCalled);
done();
});
test('Delete Proxy Action', (done) => {
test('Delete Proxy Action', async () => {
mockDeleteProxyAction = TypeMoq.Mock.ofType(DeleteProxyAction, TypeMoq.MockBehavior.Strict, DeleteProxyAction.ID, DeleteProxyAction.LABEL, null, null, mockJobManagementService);
let commandServiceCalled = false;
mockDeleteProxyAction.setup(s => s.run(TypeMoq.It.isAny())).returns(async () => {
@@ -368,10 +356,8 @@ suite('Job Management Actions', () => {
assert.equal(mockDeleteProxyAction.object.label, DeleteProxyAction.LABEL);
// Delete Proxy Action should call job management service
mockDeleteProxyAction.object.run(null);
await mockDeleteProxyAction.object.run(null);
assert(commandServiceCalled);
mockJobManagementService.verify(s => s.deleteProxy(null, null), TypeMoq.Times.once());
done();
});
});

3
src/sql/setup.js
View File

@@ -22,4 +22,7 @@ define(["require", "exports"], function (require) {
require.__$__nodeRequire('zone.js/dist/zone-error');
require.__$__nodeRequire('chart.js');
window["Zone"]["__zone_symbol__ignoreConsoleErrorUncaughtError"] = true;
window["Zone"]["__zone_symbol__unhandledPromiseRejectionHandler"] = e => setImmediate(() => {
window.dispatchEvent(new PromiseRejectionEvent('unhandledrejection', e));
}); // let window handle this
});

7
src/sql/workbench/contrib/accounts/test/browser/autoOAuthDialogController.test.ts
View File

@@ -4,6 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as TypeMoq from 'typemoq';
import * as assert from 'assert';
import { Emitter } from 'vs/base/common/event';
import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
@@ -70,7 +71,7 @@ suite('auto OAuth dialog controller tests', () => {
});
test('Open auto OAuth when the flyout is already open, return an error', (done) => {
test('Open auto OAuth when the flyout is already open, return an error', async () => {
// If: Open auto OAuth dialog first time
autoOAuthDialogController.openAutoOAuthDialog(providerId, title, message, userCode, uri);
@@ -80,8 +81,8 @@ suite('auto OAuth dialog controller tests', () => {
mockErrorMessageService.verify(x => x.showDialog(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.never());
// If: a oauth flyout is already open
autoOAuthDialogController.openAutoOAuthDialog(providerId, title, message, userCode, uri)
.then(success => done('Failure: Expected error on 2nd dialog open'), error => done());
await autoOAuthDialogController.openAutoOAuthDialog(providerId, title, message, userCode, uri)
.then(success => assert.fail('Failure: Expected error on 2nd dialog open'), error => Promise.resolve());
// Then: An error dialog should have been opened
mockErrorMessageService.verify(x => x.showDialog(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());

13
src/sql/workbench/contrib/commandLine/test/electron-browser/commandLine.test.ts
View File

@@ -19,7 +19,6 @@ import { TestConnectionManagementService } from 'sql/platform/connection/test/co
import { ICommandService } from 'vs/platform/commands/common/commands';
import { TestCommandService } from 'vs/editor/test/browser/editorTestServices';
import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
import { assertThrowsAsync } from 'sql/base/test/common/async';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { ILogService, NullLogService } from 'vs/platform/log/common/log';
import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService';
@@ -139,7 +138,7 @@ suite('commandLineService tests', () => {
return configurationService;
}
test('processCommandLine shows connection dialog by default', done => {
test('processCommandLine shows connection dialog by default', () => {
const connectionManagementService: TypeMoq.Mock<IConnectionManagementService>
= TypeMoq.Mock.ofType<IConnectionManagementService>(TestConnectionManagementService, TypeMoq.MockBehavior.Strict);
@@ -152,10 +151,9 @@ suite('commandLineService tests', () => {
.verifiable(TypeMoq.Times.never());
const configurationService = getConfigurationServiceMock(true);
let contribution = getCommandLineContribution(connectionManagementService.object, configurationService.object);
contribution.processCommandLine(new TestParsedArgs()).then(() => {
return contribution.processCommandLine(new TestParsedArgs()).then(() => {
connectionManagementService.verifyAll();
done();
}, error => { assert.fail(error, null, 'processCommandLine rejected ' + error); done(); });
}, error => { assert.fail(error, null, 'processCommandLine rejected ' + error); });
});
test('processCommandLine does nothing if no server name and command name is provided and the configuration \'workbench.showConnectDialogOnStartup\' is set to false, even if registered servers exist', async () => {
@@ -295,7 +293,10 @@ suite('commandLineService tests', () => {
.verifiable(TypeMoq.Times.once());
const configurationService = getConfigurationServiceMock(true);
let contribution = getCommandLineContribution(connectionManagementService.object, configurationService.object, capabilitiesService, commandService.object);
assertThrowsAsync(async () => await contribution.processCommandLine(args));
try {
await contribution.processCommandLine(args);
assert.fail('expected to throw');
} catch (e) { }
});
test('processCommandLine uses Integrated auth if no user name or auth type is passed', async () => {

20
src/sql/workbench/contrib/dashboard/test/electron-browser/propertiesWidget.component.test.ts
View File

@@ -37,9 +37,7 @@ class TestChangeDetectorRef extends ChangeDetectorRef {
}
suite('Dashboard Properties Widget Tests', () => {
test('Parses good config', function (done) {
// for some reason mocha thinks this test takes 26 seconds even though it doesn't, so it says this failed because it took longer than 2 seconds
this.timeout(30000);
test('Parses good config', () => {
let propertiesConfig = {
properties: [
{
@@ -106,13 +104,15 @@ suite('Dashboard Properties Widget Tests', () => {
let testComponent = new PropertiesWidgetComponent(dashboardService.object, new TestChangeDetectorRef(), undefined, widgetConfig, testLogService);
// because config parsing is done async we need to put our asserts on the thread stack
setTimeout(() => {
// because properties is private we need to do some work arounds to access it.
assert.equal((<any>testComponent).properties.length, 1);
assert.equal((<any>testComponent).properties[0].displayName, 'Test');
assert.equal((<any>testComponent).properties[0].value, 'Test Property');
done();
return new Promise(resolve => {
// because config parsing is done async we need to put our asserts on the thread stack
setImmediate(() => {
// because properties is private we need to do some work arounds to access it.
assert.equal((<any>testComponent).properties.length, 1);
assert.equal((<any>testComponent).properties[0].displayName, 'Test');
assert.equal((<any>testComponent).properties[0].value, 'Test Property');
resolve();
});
});
});
});

3
src/sql/workbench/contrib/notebook/test/browser/notebookInput.test.ts
View File

@@ -19,6 +19,7 @@ import { UntitledTextEditorInput } from 'vs/workbench/common/editor/untitledText
import { SimpleUriLabelService } from 'vs/editor/standalone/browser/simpleServices';
import { IExtensionService, NullExtensionService } from 'vs/workbench/services/extensions/common/extensions';
import { INotebookService, IProviderInfo } from 'sql/workbench/services/notebook/browser/notebookService';
import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
suite('Notebook Input', function (): void {
const instantiationService = workbenchInstantiationService();
@@ -41,6 +42,8 @@ suite('Notebook Input', function (): void {
}];
});
(instantiationService as TestInstantiationService).stub(INotebookService, mockNotebookService.object);
let untitledTextInput: UntitledTextEditorInput;
let untitledNotebookInput: UntitledNotebookInput;

6
src/sql/workbench/contrib/notebook/test/electron-browser/contentManagers.test.ts
View File

@@ -9,7 +9,6 @@ import * as assert from 'assert';
import { URI } from 'vs/base/common/uri';
import * as tempWrite from 'temp-write';
import { LocalContentManager } from 'sql/workbench/services/notebook/common/localContentManager';
import * as testUtils from '../../../../../base/test/common/async';
import { CellTypes } from 'sql/workbench/contrib/notebook/common/models/contracts';
import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
import { TestFileService } from 'vs/workbench/test/workbenchTestServices';
@@ -73,7 +72,10 @@ suite('Local Content Manager', function (): void {
});
test('Should throw if file does not exist', async function (): Promise<void> {
await testUtils.assertThrowsAsync(async () => await contentManager.getNotebookContents(URI.file('/path/doesnot/exist.ipynb')), undefined);
try {
await contentManager.getNotebookContents(URI.file('/path/doesnot/exist.ipynb'));
assert.fail('expected to throw');
} catch (e) { }
});
test('Should return notebook contents parsed as INotebook when valid notebook file parsed', async function (): Promise<void> {
// Given a file containing a valid notebook

75
src/sql/workbench/contrib/objectExplorer/test/browser/connectionTreeActions.test.ts
View File

@@ -83,7 +83,7 @@ suite('SQL Connection Tree Action tests', () => {
return objectExplorerService;
}
test('ManageConnectionAction - test if connect is called for manage action if not already connected', (done) => {
test('ManageConnectionAction - test if connect is called for manage action if not already connected', () => {
let isConnectedReturnValue: boolean = false;
let connection: ConnectionProfile = new ConnectionProfile(capabilitiesService, {
connectionName: 'Test',
@@ -127,12 +127,12 @@ suite('SQL Connection Tree Action tests', () => {
let actionContext = new ObjectExplorerActionsContext();
actionContext.connectionProfile = connection.toIConnectionProfile();
actionContext.isConnectionNode = true;
manageConnectionAction.run(actionContext).then((value) => {
return manageConnectionAction.run(actionContext).then(() => {
connectionManagementService.verify(x => x.connect(TypeMoq.It.isAny(), undefined, TypeMoq.It.isAny(), undefined), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('ManageConnectionAction - test if connect is called for manage action on database node if not already connected', (done) => {
test('ManageConnectionAction - test if connect is called for manage action on database node if not already connected', () => {
let isConnectedReturnValue: boolean = false;
let connection: ConnectionProfile = new ConnectionProfile(capabilitiesService, {
connectionName: 'Test',
@@ -165,13 +165,13 @@ suite('SQL Connection Tree Action tests', () => {
let actionContext = new ObjectExplorerActionsContext();
actionContext.connectionProfile = connection.toIConnectionProfile();
actionContext.nodeInfo = treeNode.toNodeInfo();
manageConnectionAction.run(actionContext).then((value) => {
return manageConnectionAction.run(actionContext).then((value) => {
connectionManagementService.verify(x => x.showDashboard(TypeMoq.It.isAny()), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('DisconnectConnectionAction - test if disconnect is called when profile is connected', (done) => {
test('DisconnectConnectionAction - test if disconnect is called when profile is connected', () => {
let isConnectedReturnValue: boolean = true;
let connection: ConnectionProfile = new ConnectionProfile(capabilitiesService, {
connectionName: 'Test',
@@ -194,23 +194,23 @@ suite('SQL Connection Tree Action tests', () => {
let actionContext = new ObjectExplorerActionsContext();
actionContext.connectionProfile = connection.toIConnectionProfile();
changeConnectionAction.run(actionContext).then((value) => {
return changeConnectionAction.run(actionContext).then((value) => {
connectionManagementService.verify(x => x.isProfileConnected(TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
connectionManagementService.verify(x => x.disconnect(TypeMoq.It.isAny()), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('AddServerAction - test if show connection dialog is called', (done) => {
test('AddServerAction - test if show connection dialog is called', () => {
let connectionManagementService = createConnectionManagementService(true, undefined);
let connectionTreeAction: AddServerAction = new AddServerAction(AddServerAction.ID, AddServerAction.LABEL, connectionManagementService.object);
let conProfGroup = new ConnectionProfileGroup('testGroup', undefined, 'testGroup', undefined, undefined);
connectionTreeAction.run(conProfGroup).then((value) => {
return connectionTreeAction.run(conProfGroup).then((value) => {
connectionManagementService.verify(x => x.showConnectionDialog(undefined, undefined, TypeMoq.It.isAny()), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('ActiveConnectionsFilterAction - test if view is called to display filtered results', (done) => {
test('ActiveConnectionsFilterAction - test if view is called to display filtered results', () => {
let instantiationService = TypeMoq.Mock.ofType(InstantiationService, TypeMoq.MockBehavior.Loose);
instantiationService.setup(x => x.createInstance(TypeMoq.It.isAny())).returns((input) => {
return new Promise((resolve) => resolve({}));
@@ -220,12 +220,12 @@ suite('SQL Connection Tree Action tests', () => {
serverTreeView.setup(x => x.showFilteredTree(TypeMoq.It.isAnyString()));
serverTreeView.setup(x => x.refreshTree());
let connectionTreeAction: ActiveConnectionsFilterAction = new ActiveConnectionsFilterAction(ActiveConnectionsFilterAction.ID, ActiveConnectionsFilterAction.LABEL, serverTreeView.object);
connectionTreeAction.run().then((value) => {
return connectionTreeAction.run().then((value) => {
serverTreeView.verify(x => x.showFilteredTree('active'), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('ActiveConnectionsFilterAction - test if view is called refresh results if action is toggled', (done) => {
test('ActiveConnectionsFilterAction - test if view is called refresh results if action is toggled', () => {
let instantiationService = TypeMoq.Mock.ofType(InstantiationService, TypeMoq.MockBehavior.Loose);
instantiationService.setup(x => x.createInstance(TypeMoq.It.isAny())).returns((input) => {
return new Promise((resolve) => resolve({}));
@@ -236,12 +236,12 @@ suite('SQL Connection Tree Action tests', () => {
serverTreeView.setup(x => x.refreshTree());
let connectionTreeAction: ActiveConnectionsFilterAction = new ActiveConnectionsFilterAction(ActiveConnectionsFilterAction.ID, ActiveConnectionsFilterAction.LABEL, serverTreeView.object);
connectionTreeAction.isSet = true;
connectionTreeAction.run().then((value) => {
return connectionTreeAction.run().then((value) => {
serverTreeView.verify(x => x.refreshTree(), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('RecentConnectionsFilterAction - test if view is called to display filtered results', (done) => {
test('RecentConnectionsFilterAction - test if view is called to display filtered results', () => {
let instantiationService = TypeMoq.Mock.ofType(InstantiationService, TypeMoq.MockBehavior.Loose);
instantiationService.setup(x => x.createInstance(TypeMoq.It.isAny())).returns((input) => {
return new Promise((resolve) => resolve({}));
@@ -251,12 +251,12 @@ suite('SQL Connection Tree Action tests', () => {
serverTreeView.setup(x => x.showFilteredTree(TypeMoq.It.isAnyString()));
serverTreeView.setup(x => x.refreshTree());
let connectionTreeAction: RecentConnectionsFilterAction = new RecentConnectionsFilterAction(RecentConnectionsFilterAction.ID, RecentConnectionsFilterAction.LABEL, serverTreeView.object);
connectionTreeAction.run().then((value) => {
return connectionTreeAction.run().then((value) => {
serverTreeView.verify(x => x.showFilteredTree('recent'), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('RecentConnectionsFilterAction - test if view is called refresh results if action is toggled', (done) => {
test('RecentConnectionsFilterAction - test if view is called refresh results if action is toggled', () => {
let instantiationService = TypeMoq.Mock.ofType(InstantiationService, TypeMoq.MockBehavior.Loose);
instantiationService.setup(x => x.createInstance(TypeMoq.It.isAny())).returns((input) => {
return new Promise((resolve) => resolve({}));
@@ -267,12 +267,12 @@ suite('SQL Connection Tree Action tests', () => {
serverTreeView.setup(x => x.refreshTree());
let connectionTreeAction: RecentConnectionsFilterAction = new RecentConnectionsFilterAction(RecentConnectionsFilterAction.ID, RecentConnectionsFilterAction.LABEL, serverTreeView.object);
connectionTreeAction.isSet = true;
connectionTreeAction.run().then((value) => {
return connectionTreeAction.run().then((value) => {
serverTreeView.verify(x => x.refreshTree(), TypeMoq.Times.once());
}).then(() => done(), (err) => done(err));
});
});
test('DeleteConnectionAction - test delete connection', (done) => {
test('DeleteConnectionAction - test delete connection', () => {
let connectionManagementService = createConnectionManagementService(true, undefined);
let connection: ConnectionProfile = new ConnectionProfile(capabilitiesService, {
@@ -295,13 +295,13 @@ suite('SQL Connection Tree Action tests', () => {
connection,
connectionManagementService.object);
connectionAction.run().then((value) => {
return connectionAction.run().then((value) => {
connectionManagementService.verify(x => x.deleteConnection(TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
}).then(() => done(), (err) => done(err));
});
});
test('DeleteConnectionAction - test delete connection group', (done) => {
test('DeleteConnectionAction - test delete connection group', () => {
let isConnectedReturnValue: boolean = false;
let connectionManagementService = createConnectionManagementService(isConnectedReturnValue, undefined);
let conProfGroup = new ConnectionProfileGroup('testGroup', undefined, 'testGroup', undefined, undefined);
@@ -310,13 +310,13 @@ suite('SQL Connection Tree Action tests', () => {
conProfGroup,
connectionManagementService.object);
connectionAction.run().then((value) => {
return connectionAction.run().then((value) => {
connectionManagementService.verify(x => x.deleteConnectionGroup(TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
}).then(() => done(), (err) => done(err));
});
});
test('DeleteConnectionAction - delete should not be called if connect is an unsaved connection', (done) => {
test('DeleteConnectionAction - delete should not be called if connect is an unsaved connection', () => {
let isConnectedReturnValue: boolean = false;
let connectionManagementService = createConnectionManagementService(isConnectedReturnValue, undefined);
@@ -342,10 +342,9 @@ suite('SQL Connection Tree Action tests', () => {
connectionManagementService.object);
assert.equal(connectionAction.enabled, false, 'delete action should be disabled.');
done();
});
test('RefreshConnectionAction - refresh should be called if connection status is connect', (done) => {
test('RefreshConnectionAction - refresh should be called if connection status is connect', () => {
let isConnectedReturnValue: boolean = true;
let sqlProvider = {
providerId: mssqlProviderName,
@@ -423,17 +422,15 @@ suite('SQL Connection Tree Action tests', () => {
undefined,
logService);
connectionAction.run().then((value) => {
return connectionAction.run().then((value) => {
connectionManagementService.verify(x => x.isConnected(undefined, TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
objectExplorerService.verify(x => x.getObjectExplorerNode(TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
objectExplorerService.verify(x => x.refreshTreeNode(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
tree.verify(x => x.refresh(TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
}).then(() => done(), (err) => {
done(err);
});
});
test('RefreshConnectionAction - refresh should not be called if connection status is not connect', (done) => {
test('RefreshConnectionAction - refresh should not be called if connection status is not connect', () => {
let isConnectedReturnValue: boolean = false;
let sqlProvider = {
providerId: mssqlProviderName,
@@ -510,13 +507,13 @@ suite('SQL Connection Tree Action tests', () => {
undefined,
logService);
connectionAction.run().then((value) => {
return connectionAction.run().then((value) => {
connectionManagementService.verify(x => x.isConnected(undefined, TypeMoq.It.isAny()), TypeMoq.Times.atLeastOnce());
objectExplorerService.verify(x => x.getObjectExplorerNode(TypeMoq.It.isAny()), TypeMoq.Times.exactly(0));
objectExplorerService.verify(x => x.refreshTreeNode(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.exactly(0));
tree.verify(x => x.refresh(TypeMoq.It.isAny()), TypeMoq.Times.exactly(0));
tree.verify(x => x.expand(TypeMoq.It.isAny()), TypeMoq.Times.exactly(0));
}).then(() => done(), (err) => done(err));
});
});
});

62
src/sql/workbench/contrib/query/test/browser/queryActions.test.ts
View File

@@ -77,17 +77,16 @@ suite('SQL QueryAction Tests', () => {
testQueryInput.setup(x => x.runQuery(undefined)).callback(() => { calledRunQueryOnInput = true; });
});
test('setClass sets child CSS class correctly', (done) => {
test('setClass sets child CSS class correctly', () => {
// If I create a RunQueryAction
let queryAction: QueryTaskbarAction = new RunQueryAction(undefined, undefined, undefined);
// "class should automatically get set to include the base class and the RunQueryAction class
let className = RunQueryAction.EnabledClass;
assert.equal(queryAction.class, className, 'CSS class not properly set');
done();
});
test('getConnectedQueryEditorUri returns connected URI only if connected', (done) => {
test('getConnectedQueryEditorUri returns connected URI only if connected', () => {
// ... Create assert variables
let isConnectedReturnValue: boolean = false;
@@ -114,10 +113,9 @@ suite('SQL QueryAction Tests', () => {
// I should get a connected state
assert(connected, 'Connected editor should get back a non-undefined URI');
done();
});
test('RunQueryAction calls runQuery() only if URI is connected', (done) => {
test('RunQueryAction calls runQuery() only if URI is connected', async () => {
// ... Create assert variables
let isConnected: boolean = undefined;
let connectionParams: INewConnectionParams = undefined;
@@ -141,7 +139,7 @@ suite('SQL QueryAction Tests', () => {
let queryAction: RunQueryAction = new RunQueryAction(editor.object, queryModelService.object, connectionManagementService.object);
isConnected = false;
calledRunQueryOnInput = false;
queryAction.run();
await queryAction.run();
// runQuery should not be run
assert.equal(calledRunQueryOnInput, false, 'run should not call runQuery');
@@ -155,17 +153,16 @@ suite('SQL QueryAction Tests', () => {
// If I call run on RunQueryAction when I am connected
isConnected = true;
queryAction.run();
await queryAction.run();
//runQuery should be run, and the conneciton dialog should not open
assert.equal(calledRunQueryOnInput, true, 'run should call runQuery');
testQueryInput.verify(x => x.runQuery(undefined), TypeMoq.Times.once());
assert.equal(countCalledShowDialog, 1, 'run should not call showDialog');
done();
});
test('Queries are only run if the QueryEditor selection is not empty', (done) => {
test('Queries are only run if the QueryEditor selection is not empty', async () => {
// ... Create assert variables
let isSelectionEmpty: boolean = undefined;
let countCalledRunQuery: number = 0;
@@ -199,21 +196,20 @@ suite('SQL QueryAction Tests', () => {
// If I call run on RunQueryAction when I have a non empty selection
let queryAction: RunQueryAction = new RunQueryAction(queryEditor.object, queryModelService.object, connectionManagementService.object);
isSelectionEmpty = false;
queryAction.run();
await queryAction.run();
//runQuery should be run
assert.equal(countCalledRunQuery, 1, 'runQuery should be called');
// If I call run on RunQueryAction when I have an empty selection
isSelectionEmpty = true;
queryAction.run();
await queryAction.run();
//runQuery should not be run again
assert.equal(countCalledRunQuery, 1, 'runQuery should not be called again');
done();
});
test('ISelectionData is properly passed when queries are run', () => {
test('ISelectionData is properly passed when queries are run', async () => {
/// Setup Test ///
@@ -269,7 +265,7 @@ suite('SQL QueryAction Tests', () => {
let queryAction: RunQueryAction = new RunQueryAction(queryEditor.object, undefined, connectionManagementService.object);
isConnected = false;
selectionToReturnInGetSelection = undefined;
queryAction.run();
await queryAction.run();
// The conneciton dialog should open with an undefined seleciton
assert.equal(countCalledShowDialog, 1, 'run should call showDialog');
@@ -280,7 +276,7 @@ suite('SQL QueryAction Tests', () => {
////// If I call run on RunQueryAction while disconnected and with a defined selection
isConnected = false;
selectionToReturnInGetSelection = predefinedSelection;
queryAction.run();
await queryAction.run();
// The conneciton dialog should open with the correct seleciton
assert.equal(countCalledShowDialog, 2, 'run should call showDialog again');
@@ -295,7 +291,7 @@ suite('SQL QueryAction Tests', () => {
////// If I call run on RunQueryAction while connected and with an undefined selection
isConnected = true;
selectionToReturnInGetSelection = undefined;
queryAction.run();
await queryAction.run();
// The query should run with an undefined selection
assert.equal(countCalledShowDialog, 2, 'run should not call showDialog');
@@ -305,7 +301,7 @@ suite('SQL QueryAction Tests', () => {
////// If I call run on RunQueryAction while connected and with a defined selection
isConnected = true;
selectionToReturnInGetSelection = predefinedSelection;
queryAction.run();
await queryAction.run();
// The query should run with the given seleciton
assert.equal(countCalledShowDialog, 2, 'run should not call showDialog');
@@ -317,7 +313,7 @@ suite('SQL QueryAction Tests', () => {
assert.equal(runQuerySelection.endColumn, selectionToReturnInGetSelection.endColumn, 'endColumn should match');
});
test('CancelQueryAction calls cancelQuery() only if URI is connected', (done) => {
test('CancelQueryAction calls cancelQuery() only if URI is connected', async () => {
// ... Create assert variables
let isConnected: boolean = undefined;
let calledCancelQuery: boolean = false;
@@ -334,22 +330,21 @@ suite('SQL QueryAction Tests', () => {
// If I call run on CancelQueryAction when I am not connected
let queryAction: CancelQueryAction = new CancelQueryAction(editor.object, queryModelService.object, connectionManagementService.object);
isConnected = false;
queryAction.run();
await queryAction.run();
// cancelQuery should not be run
assert.equal(calledCancelQuery, false, 'run should not call cancelQuery');
// If I call run on CancelQueryAction when I am connected
isConnected = true;
queryAction.run();
await queryAction.run();
// cancelQuery should be run
assert.equal(calledCancelQuery, true, 'run should call cancelQuery');
done();
});
// We want to call disconnectEditor regardless of connection to be able to cancel in-progress connections
test('DisconnectDatabaseAction calls disconnectEditor regardless of URI being connected', (done) => {
test('DisconnectDatabaseAction calls disconnectEditor regardless of URI being connected', async () => {
// ... Create assert variables
let isConnected: boolean = undefined;
let countCalledDisconnectEditor: number = 0;
@@ -363,21 +358,20 @@ suite('SQL QueryAction Tests', () => {
// If I call run on DisconnectDatabaseAction when I am not connected
let queryAction: DisconnectDatabaseAction = new DisconnectDatabaseAction(editor.object, connectionManagementService.object);
isConnected = false;
queryAction.run();
await queryAction.run();
// disconnectEditor should be run
assert.equal(countCalledDisconnectEditor, 1, 'disconnectEditor should be called when URI is not connected');
// If I call run on DisconnectDatabaseAction when I am connected
isConnected = true;
queryAction.run();
await queryAction.run();
// disconnectEditor should be run again
assert.equal(countCalledDisconnectEditor, 2, 'disconnectEditor should be called when URI is connected');
done();
});
test('ConnectDatabaseAction opens dialog regardless of URI connection state', (done) => {
test('ConnectDatabaseAction opens dialog regardless of URI connection state', async () => {
// ... Create assert variables
let isConnected: boolean = undefined;
let connectionParams: INewConnectionParams = undefined;
@@ -395,7 +389,7 @@ suite('SQL QueryAction Tests', () => {
// If I call run on ConnectDatabaseAction when I am not connected
let queryAction: ConnectDatabaseAction = new ConnectDatabaseAction(editor.object, false, connectionManagementService.object);
isConnected = false;
queryAction.run();
await queryAction.run();
// The conneciton dialog should open with the correct parameter details
assert.equal(countCalledShowDialog, 1, 'run should call showDialog');
@@ -406,7 +400,7 @@ suite('SQL QueryAction Tests', () => {
// If I call run on ConnectDatabaseAction when I am connected
isConnected = true;
queryAction.run();
await queryAction.run();
// The conneciton dialog should open again with the correct parameter details
assert.equal(countCalledShowDialog, 2, 'run should call showDialog');
@@ -414,10 +408,9 @@ suite('SQL QueryAction Tests', () => {
assert.equal(connectionParams.runQueryOnCompletion, false, 'runQueryOnCompletion should be false`');
assert.equal(connectionParams.input.uri, testUri, 'URI should be set to the test URI');
assert.equal(connectionParams.input, editor.object.input, 'Editor should be set to the mock editor');
done();
});
test('ChangeConnectionAction connects regardless of URI being connected', (done) => {
test('ChangeConnectionAction connects regardless of URI being connected', async () => {
// ... Create assert variables
let queryAction: ConnectDatabaseAction = undefined;
let isConnected: boolean = undefined;
@@ -435,7 +428,7 @@ suite('SQL QueryAction Tests', () => {
// If I call run on ChangeConnectionAction when I am not connected
queryAction = new ConnectDatabaseAction(editor.object, false, connectionManagementService.object);
isConnected = false;
queryAction.run();
await queryAction.run();
// The connection dialog should open with the params set as below
assert.equal(calledShowDialog, 1, 'showDialog should be called when URI is connected');
@@ -445,7 +438,7 @@ suite('SQL QueryAction Tests', () => {
assert.equal(connectionParams.input, editor.object.input, 'Editor should be set to the mock editor');
// Then if I call run on ChangeConnectionAction when I am connected
isConnected = true;
queryAction.run();
await queryAction.run();
// The conneciton dialog should open with the params set as below
assert.equal(calledShowDialog, 2, 'showDialog should be called when URI is connected');
@@ -453,10 +446,9 @@ suite('SQL QueryAction Tests', () => {
assert.equal(connectionParams.runQueryOnCompletion, false, 'runQueryOnCompletion should be false`');
assert.equal(connectionParams.input.uri, testUri, 'URI should be set to the test URI');
assert.equal(connectionParams.input, editor.object.input, 'Editor should be set to the mock editor');
done();
});
test('ListDatabaseItem shows items as expected', (done) => {
test('ListDatabaseItem shows items as expected', () => {
// ... Create assert variables
let listItem: ListDatabasesActionItem = undefined;
let isConnected: boolean = undefined;
@@ -488,8 +480,6 @@ suite('SQL QueryAction Tests', () => {
listItem.onDisconnect();
assert.equal(listItem.isEnabled(), false, 'do not expect dropdown enabled unless connected');
assert.equal(listItem.currentDatabaseName, undefined, 'do not expect dropdown to have entries unless connected');
done();
});
test('ListDatabaseItem - null event params', () => {

7
src/sql/workbench/services/accountManagement/browser/accountManagementService.ts
View File

@@ -105,12 +105,7 @@ export class AccountManagementService implements IAccountManagementService {
}
return Promise.resolve();
});
}).then(
() => { },
reason => {
console.warn(`Account update handler encountered error: ${reason}`);
}
);
});
}

179
src/sql/workbench/services/accountManagement/test/browser/accountManagementService.test.ts
View File

@@ -56,7 +56,7 @@ suite('Account Management Service Tests:', () => {
assert.ok(ams.updateAccountListEvent);
});
test('Account Updated - account added', done => {
test('Account Updated - account added', async () => {
// Setup:
// ... Create account management service and to mock up the store
let state = getTestState();
@@ -79,19 +79,16 @@ suite('Account Management Service Tests:', () => {
};
// If: I update an account that doesn't exist
state.accountManagementService.accountUpdated(account)
.then(() => {
// Then: Make sure the mocked methods are called
state.mockAccountStore.verify(x => x.addOrUpdate(TypeMoq.It.isAny()), TypeMoq.Times.once());
state.mockAccountStore.verify(x => x.remove(TypeMoq.It.isAny()), TypeMoq.Times.once());
})
.then(
() => done(),
err => done(err)
);
try {
await state.accountManagementService.accountUpdated(account);
assert.fail('Should have failed with new account being added');
} catch (e) {
state.mockAccountStore.verify(x => x.addOrUpdate(TypeMoq.It.isAny()), TypeMoq.Times.once());
state.mockAccountStore.verify(x => x.remove(TypeMoq.It.isAny()), TypeMoq.Times.once());
}
});
test('Account Updated - account modified', done => {
test('Account Updated - account modified', () => {
// Setup:
// ... Create account management service and to mock up the store
let state = getTestState();
@@ -111,7 +108,7 @@ suite('Account Management Service Tests:', () => {
metadata: hasAccountProvider
};
// If: I update an account that exists
state.accountManagementService.accountUpdated(account)
return state.accountManagementService.accountUpdated(account)
.then(() => {
// Then:
// ... The mocked method was called
@@ -123,14 +120,10 @@ suite('Account Management Service Tests:', () => {
assert.ok(Array.isArray(params.accountList));
assert.equal(params.accountList.length, 1);
});
})
.then(
() => done(),
err => done(err)
);
});
});
test('Add account - provider exists, account does not exist', done => {
test('Add account - provider exists, account does not exist', () => {
// Setup:
// ... Create account management service with a provider
let state = getTestState();
@@ -166,14 +159,10 @@ suite('Account Management Service Tests:', () => {
assert.equal(param.accountList.length, 1);
assert.equal(param.accountList[0], account);
});
})
.then(
() => done(),
err => done(err)
);
});
});
test('Add account - provider exists, account exists', done => {
test('Add account - provider exists, account exists', () => {
// Setup:
// ... Create account management service with a provider
let state = getTestState();
@@ -209,28 +198,22 @@ suite('Account Management Service Tests:', () => {
assert.equal(param.accountList.length, 1);
assert.equal(param.accountList[0], account);
});
})
.then(
() => done(),
err => done(err)
);
});
});
test('Add account - provider doesn\'t exist', done => {
test('Add account - provider doesn\'t exist', () => {
// Setup: Create account management service
let ams = getTestState().accountManagementService;
// If: I add an account when the provider doesn't exist
// Then: It should not resolve
Promise.race([
return Promise.race([
new Promise((resolve, reject) => setTimeout(() => resolve(), 100)),
ams.addAccount('doesNotExist').then((
() => done('Promise resolved when the provider did not exist')
))
]).then(() => done(), err => done(err));
ams.addAccount('doesNotExist').then(() => { throw new Error('Promise resolved when the provider did not exist'); })
]);
});
test('Add account - provider exists, provider fails', done => {
test('Add account - provider exists, provider fails', async () => {
// Setup: Create account management service with a provider
let state = getTestState();
let mockProvider = getFailingMockAccountProvider(false);
@@ -238,14 +221,13 @@ suite('Account Management Service Tests:', () => {
// If: I ask to add an account and the user cancels
// Then: Nothing should have happened and the promise should be resolved
return state.accountManagementService.addAccount(noAccountProvider.id)
.then(
() => done('Add account promise resolved when it should have rejected'),
() => done()
);
try {
await state.accountManagementService.addAccount(noAccountProvider.id);
assert.fail('Add account promise resolved when it should have rejected');
} catch (e) { }
});
test('Add account - provider exists, user cancelled', done => {
test('Add account - provider exists, user cancelled', () => {
// Setup: Create account management service with a provider
let state = getTestState();
let mockProvider = getFailingMockAccountProvider(true);
@@ -253,14 +235,10 @@ suite('Account Management Service Tests:', () => {
// If: I ask to add an account and the user cancels
// Then: Nothing should have happened and the promise should be resolved
return state.accountManagementService.addAccount(noAccountProvider.id)
.then(
() => done(),
err => done(err)
);
return state.accountManagementService.addAccount(noAccountProvider.id);
});
test('Get account provider metadata - providers exist', done => {
test('Get account provider metadata - providers exist', () => {
// Setup: Create account management service with a provider
let state = getTestState();
state.accountManagementService._providers[noAccountProvider.id] = {
@@ -276,45 +254,35 @@ suite('Account Management Service Tests:', () => {
assert.ok(Array.isArray(result));
assert.equal(result.length, 1);
assert.equal(result[0], noAccountProvider);
})
.then(
() => done(),
err => done(err)
);
});
});
test('Get account provider metadata - no providers', done => {
test('Get account provider metadata - no providers', () => {
// Setup: Create account management service
let ams = getTestState().accountManagementService;
// If: I ask for account provider metadata when there isn't any providers
ams.getAccountProviderMetadata()
return ams.getAccountProviderMetadata()
.then(result => {
// Then: The results should be an empty array
assert.ok(Array.isArray(result));
assert.equal(result.length, 0);
})
.then(
() => done(),
err => done(err)
);
});
});
test('Get accounts by provider - provider does not exist', done => {
test('Get accounts by provider - provider does not exist', () => {
// Setup: Create account management service
let ams = getTestState().accountManagementService;
// If: I get accounts when the provider doesn't exist
// Then: It should not resolve
Promise.race([
return Promise.race([
new Promise((resolve, reject) => setTimeout(() => resolve(), 100)),
ams.getAccountsForProvider('doesNotExist').then((
() => done('Promise resolved when the provider did not exist')
))
]).then(() => done(), err => done(err));
ams.getAccountsForProvider('doesNotExist').then(() => { throw new Error('Promise resolved when the provider did not exist'); })
]);
});
test('Get accounts by provider - provider exists, no accounts', done => {
test('Get accounts by provider - provider exists, no accounts', () => {
// Setup: Create account management service
let ams = getTestState().accountManagementService;
ams._providers[noAccountProvider.id] = {
@@ -324,19 +292,15 @@ suite('Account Management Service Tests:', () => {
};
// If: I ask for the accounts for a provider with no accounts
ams.getAccountsForProvider(noAccountProvider.id)
return ams.getAccountsForProvider(noAccountProvider.id)
.then(result => {
// Then: I should get back an empty array
assert.ok(Array.isArray(result));
assert.equal(result.length, 0);
})
.then(
() => done(),
err => done(err)
);
});
});
test('Get accounts by provider - provider exists, has accounts', done => {
test('Get accounts by provider - provider exists, has accounts', () => {
// Setup: Create account management service
let ams = getTestState().accountManagementService;
ams._providers[hasAccountProvider.id] = {
@@ -346,18 +310,14 @@ suite('Account Management Service Tests:', () => {
};
// If: I ask for the accounts for a provider with accounts
ams.getAccountsForProvider(hasAccountProvider.id)
return ams.getAccountsForProvider(hasAccountProvider.id)
.then(result => {
// Then: I should get back the list of accounts
assert.equal(result, accountList);
})
.then(
() => done(),
err => done(err)
);
});
});
test('Remove account - account exists', done => {
test('Remove account - account exists', () => {
// Setup:
// ... Create account management service and to fake removing an account that exists
let state = getTestState();
@@ -374,7 +334,7 @@ suite('Account Management Service Tests:', () => {
};
// If: I remove an account that exists
state.accountManagementService.removeAccount(account.key)
return state.accountManagementService.removeAccount(account.key)
.then(result => {
// Then:
// ... I should have gotten true back
@@ -392,14 +352,10 @@ suite('Account Management Service Tests:', () => {
assert.ok(Array.isArray(params.accountList));
assert.equal(params.accountList.length, 0);
});
})
.then(
() => done(),
err => done(err)
);
});
});
test('Remove account - account doesn\'t exist', done => {
test('Remove account - account doesn\'t exist', () => {
// Setup:
// ... Create account management service and to fake removing an account that doesn't exist
let state = getTestState();
@@ -417,7 +373,7 @@ suite('Account Management Service Tests:', () => {
// If: I remove an account that doesn't exist
let accountKey = { providerId: noAccountProvider.id, accountId: 'foobar' };
state.accountManagementService.removeAccount(accountKey)
return state.accountManagementService.removeAccount(accountKey)
.then(result => {
// Then:
// ... I should have gotten false back
@@ -431,14 +387,10 @@ suite('Account Management Service Tests:', () => {
// ... The updated account list event should not have fired
state.eventVerifierUpdate.assertNotFired();
})
.then(
() => done(),
err => done(err)
);
});
});
test('Open account dialog - first call', done => {
test('Open account dialog - first call', () => {
// Setup:
// ... Create account management ervice
let state = getTestState();
@@ -450,7 +402,7 @@ suite('Account Management Service Tests:', () => {
.returns(() => mockDialogController.object);
// If: I open the account dialog when it doesn't exist
state.accountManagementService.openAccountListDialog()
return state.accountManagementService.openAccountListDialog()
.then(() => {
// Then:
// ... The instantiation service should have been called once
@@ -458,14 +410,10 @@ suite('Account Management Service Tests:', () => {
// ... The dialog should have been opened
mockDialogController.verify(x => x.openAccountDialog(), TypeMoq.Times.once());
})
.then(
() => done(),
err => done(err)
);
});
});
test('Open account dialog - subsequent calls', done => {
test('Open account dialog - subsequent calls', () => {
// Setup:
// ... Create account management ervice
let state = getTestState();
@@ -477,7 +425,7 @@ suite('Account Management Service Tests:', () => {
.returns(() => mockDialogController.object);
// If: I open the account dialog for a second time
state.accountManagementService.openAccountListDialog()
return state.accountManagementService.openAccountListDialog()
.then(() => state.accountManagementService.openAccountListDialog())
.then(() => {
// Then:
@@ -486,18 +434,14 @@ suite('Account Management Service Tests:', () => {
// ... The dialog should have been opened twice
mockDialogController.verify(x => x.openAccountDialog(), TypeMoq.Times.exactly(2));
})
.then(
() => done(),
err => done(err)
);
});
});
// test('Perform oauth - success', done => {
// TODO: implement this test properly once we remove direct IPC calls (see https://github.com/Microsoft/carbon/issues/2091)
// });
test('Register provider - success', done => {
test('Register provider - success', () => {
// Setup:
// ... Create ams, account store that will accept account add/update
let mocks = getTestState();
@@ -508,7 +452,7 @@ suite('Account Management Service Tests:', () => {
let mockProvider = getMockAccountProvider();
// If: I register a new provider
mocks.accountManagementService.registerProvider(noAccountProvider, mockProvider.object)
return mocks.accountManagementService.registerProvider(noAccountProvider, mockProvider.object)
.then(() => {
// Then:
// ... Account store should have been called to get dehydrated accounts
@@ -523,29 +467,24 @@ suite('Account Management Service Tests:', () => {
assert.ok(Array.isArray(param.initialAccounts));
assert.equal(param.initialAccounts.length, 0);
});
})
.then(
() => done(),
err => done(err)
);
});
});
test('Unregister provider - success', done => {
test('Unregister provider - success', () => {
// Setup:
// ... Create ams
let mocks = getTestState();
// ... Register a provider to remove
let mockProvider = getMockAccountProvider();
mocks.accountManagementService.registerProvider(noAccountProvider, mockProvider.object)
return mocks.accountManagementService.registerProvider(noAccountProvider, mockProvider.object)
.then((success) => {
// If: I remove an account provider
mocks.accountManagementService.unregisterProvider(noAccountProvider);
// Then: The provider removed event should have fired
mocks.eventVerifierProviderRemoved.assertFired(noAccountProvider);
}, error => {
}).then(() => done(), err => done(err));
});
});
});

2
src/sql/workbench/services/connection/browser/connectionManagementService.ts
View File

@@ -193,7 +193,7 @@ export class ConnectionManagementService extends Disposable implements IConnecti
// Connection Provider Registration
public registerProvider(providerId: string, provider: azdata.ConnectionProvider): void {
if (!this._providers.has(providerId)) {
console.error('Provider', providerId, 'attempted to register but has no metadata');
this._logService.warn('Provider', providerId, 'attempted to register but has no metadata');
let providerType = {
onReady: new Deferred<azdata.ConnectionProvider>(),
properties: undefined

12
src/sql/workbench/services/connection/test/browser/connectionDialogService.test.ts
View File

@@ -75,15 +75,11 @@ suite('ConnectionDialogService tests', () => {
});
}
test('handleDefaultOnConnect uses params URI for editor connections', done => {
testHandleDefaultOnConnectUri(true).then(() => done(), err => {
done(err);
});
test('handleDefaultOnConnect uses params URI for editor connections', () => {
return testHandleDefaultOnConnectUri(true);
});
test('handleDefaultOnConnect uses undefined URI for non-editor connections', done => {
testHandleDefaultOnConnectUri(false).then(() => done(), err => {
done(err);
});
test('handleDefaultOnConnect uses undefined URI for non-editor connections', () => {
return testHandleDefaultOnConnectUri(false);
});
});

196
src/sql/workbench/services/connection/test/browser/connectionManagementService.test.ts
View File

@@ -242,16 +242,13 @@ suite('SQL ConnectionManagementService tests', () => {
}
}
test('showConnectionDialog should open the dialog with default type given no parameters', done => {
connectionManagementService.showConnectionDialog().then(() => {
test('showConnectionDialog should open the dialog with default type given no parameters', () => {
return connectionManagementService.showConnectionDialog().then(() => {
verifyShowConnectionDialog(undefined, ConnectionType.default, undefined, false);
done();
}).catch(err => {
done(err);
});
});
test('showConnectionDialog should open the dialog with given type given valid input', done => {
test('showConnectionDialog should open the dialog with given type given valid input', () => {
let params: INewConnectionParams = {
connectionType: ConnectionType.editor,
input: {
@@ -264,15 +261,12 @@ suite('SQL ConnectionManagementService tests', () => {
},
runQueryOnCompletion: RunQueryOnConnectionMode.executeQuery
};
connectionManagementService.showConnectionDialog(params).then(() => {
return connectionManagementService.showConnectionDialog(params).then(() => {
verifyShowConnectionDialog(undefined, params.connectionType, params.input.uri, false);
done();
}).catch(err => {
done(err);
});
});
test('showConnectionDialog should pass the model to the dialog if there is a model assigned to the uri', done => {
test('showConnectionDialog should pass the model to the dialog if there is a model assigned to the uri', () => {
let params: INewConnectionParams = {
connectionType: ConnectionType.editor,
input: {
@@ -286,21 +280,18 @@ suite('SQL ConnectionManagementService tests', () => {
runQueryOnCompletion: RunQueryOnConnectionMode.executeQuery
};
connect(params.input.uri).then(() => {
return connect(params.input.uri).then(() => {
let saveConnection = connectionManagementService.getConnectionProfile(params.input.uri);
assert.notEqual(saveConnection, undefined, `profile was not added to the connections`);
assert.equal(saveConnection.serverName, connectionProfile.serverName, `Server names are different`);
connectionManagementService.showConnectionDialog(params).then(() => {
return connectionManagementService.showConnectionDialog(params).then(() => {
verifyShowConnectionDialog(connectionProfile, params.connectionType, params.input.uri, false);
done();
}).catch(err => {
done(err);
});
}, err => done(err));
});
});
test('connect should save profile given options with saveProfile set to true', done => {
test('connect should save profile given options with saveProfile set to true', () => {
let uri: string = 'Editor Uri';
let options: IConnectionCompletionOptions = {
params: undefined,
@@ -310,18 +301,14 @@ suite('SQL ConnectionManagementService tests', () => {
showFirewallRuleOnError: true
};
connect(uri, options).then(() => {
return connect(uri, options).then(() => {
verifyOptions(options);
done();
}).catch(err => {
done(err);
});
});
test('getDefaultProviderId is MSSQL', done => {
test('getDefaultProviderId is MSSQL', () => {
let defaultProvider = connectionManagementService.getDefaultProviderId();
assert.equal(defaultProvider, 'MSSQL', `Default provider is not equal to MSSQL`);
done();
});
/* Andresse 10/5/17 commented this test out since it was only working before my changes by the chance of how Promises work
@@ -343,7 +330,7 @@ suite('SQL ConnectionManagementService tests', () => {
// });
// });
test('connect should pass the params in options to onConnectSuccess callback', done => {
test('connect should pass the params in options to onConnectSuccess callback', () => {
let uri: string = 'Editor Uri';
let paramsInOnConnectSuccess: INewConnectionParams;
let options: IConnectionCompletionOptions = {
@@ -368,41 +355,32 @@ suite('SQL ConnectionManagementService tests', () => {
showFirewallRuleOnError: true
};
connect(uri, options).then(() => {
return connect(uri, options).then(() => {
verifyOptions(options);
assert.notEqual(paramsInOnConnectSuccess, undefined);
assert.equal(paramsInOnConnectSuccess.connectionType, options.params.connectionType);
done();
}).catch(err => {
done(err);
});
});
test('connectAndSaveProfile should show not load the password', done => {
test('connectAndSaveProfile should show not load the password', () => {
let uri: string = 'Editor Uri';
let options: IConnectionCompletionOptions = undefined;
connect(uri, options, true).then(() => {
return connect(uri, options, true).then(() => {
verifyOptions(options, true);
done();
}).catch(err => {
done(err);
});
});
test('connect with undefined uri and options should connect using the default uri', done => {
test('connect with undefined uri and options should connect using the default uri', () => {
let uri = undefined;
let options: IConnectionCompletionOptions = undefined;
connect(uri, options).then(() => {
return connect(uri, options).then(() => {
assert.equal(connectionManagementService.isProfileConnected(connectionProfile), true);
done();
}).catch(err => {
done(err);
});
});
test('failed connection should open the dialog if connection fails', done => {
test('failed connection should open the dialog if connection fails', () => {
let uri = undefined;
let error: string = 'error';
let errorCode: number = 111;
@@ -423,18 +401,15 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: errorCallStack
};
connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
return connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, connectionResult.errorMessage);
verifyShowFirewallRuleDialog(connectionProfile, false);
verifyShowConnectionDialog(connectionProfile, ConnectionType.default, uri, true, connectionResult);
done();
}).catch(err => {
done(err);
});
});
test('failed connection should not open the dialog if the option is set to false even if connection fails', done => {
test('failed connection should not open the dialog if the option is set to false even if connection fails', () => {
let uri = undefined;
let error: string = 'error when options set to false';
let errorCode: number = 111;
@@ -455,18 +430,15 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: errorCallStack
};
connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
return connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, connectionResult.errorMessage);
verifyShowFirewallRuleDialog(connectionProfile, false);
verifyShowConnectionDialog(connectionProfile, ConnectionType.default, uri, true, connectionResult, false);
done();
}).catch(err => {
done(err);
});
});
test('failed firewall rule should open the firewall rule dialog', done => {
test('failed firewall rule should open the firewall rule dialog', () => {
handleFirewallRuleResult.canHandleFirewallRule = true;
resolveHandleFirewallRuleDialog = true;
isFirewallRuleAdded = true;
@@ -484,17 +456,14 @@ suite('SQL ConnectionManagementService tests', () => {
showFirewallRuleOnError: true
};
connect(uri, options, false, connectionProfile, error, errorCode).then(result => {
return connect(uri, options, false, connectionProfile, error, errorCode).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, expectedError);
verifyShowFirewallRuleDialog(connectionProfile, true);
done();
}).catch(err => {
done(err);
});
});
test('failed firewall rule connection should not open the firewall rule dialog if the option is set to false even if connection fails', done => {
test('failed firewall rule connection should not open the firewall rule dialog if the option is set to false even if connection fails', () => {
handleFirewallRuleResult.canHandleFirewallRule = true;
resolveHandleFirewallRuleDialog = true;
isFirewallRuleAdded = true;
@@ -519,20 +488,17 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: errorCallStack
};
connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
return connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, connectionResult.errorMessage);
verifyShowFirewallRuleDialog(connectionProfile, false);
verifyShowConnectionDialog(connectionProfile, ConnectionType.default, uri, true, connectionResult, false);
done();
}).catch(err => {
done(err);
});
});
test('failed firewall rule connection and failed during open firewall rule should open the firewall rule dialog and connection dialog with error', done => {
test('failed firewall rule connection and failed during open firewall rule should open the firewall rule dialog and connection dialog with error', () => {
handleFirewallRuleResult.canHandleFirewallRule = true;
resolveHandleFirewallRuleDialog = false;
resolveHandleFirewallRuleDialog = true;
isFirewallRuleAdded = true;
let uri = undefined;
@@ -555,18 +521,15 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: errorCallStack
};
connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
return connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, connectionResult.errorMessage);
verifyShowFirewallRuleDialog(connectionProfile, true);
verifyShowConnectionDialog(connectionProfile, ConnectionType.default, uri, true, connectionResult, true);
done();
}).catch(err => {
done(err);
});
});
test('failed firewall rule connection should open the firewall rule dialog. Then canceled firewall rule dialog should not open connection dialog', done => {
test('failed firewall rule connection should open the firewall rule dialog. Then canceled firewall rule dialog should not open connection dialog', () => {
handleFirewallRuleResult.canHandleFirewallRule = true;
resolveHandleFirewallRuleDialog = true;
isFirewallRuleAdded = false;
@@ -591,17 +554,14 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: errorCallStack
};
connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
return connect(uri, options, false, connectionProfile, error, errorCode, errorCallStack).then(result => {
assert.equal(result, undefined);
verifyShowFirewallRuleDialog(connectionProfile, true);
verifyShowConnectionDialog(connectionProfile, ConnectionType.default, uri, true, connectionResult, false);
done();
}).catch(err => {
done(err);
});
});
test('connect when password is empty and unsaved should open the dialog', done => {
test('connect when password is empty and unsaved should open the dialog', () => {
let uri = undefined;
let expectedConnection: boolean = false;
let options: IConnectionCompletionOptions = {
@@ -619,18 +579,15 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: undefined
};
connect(uri, options, false, connectionProfileWithEmptyUnsavedPassword).then(result => {
return connect(uri, options, false, connectionProfileWithEmptyUnsavedPassword).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, connectionResult.errorMessage);
verifyShowConnectionDialog(connectionProfileWithEmptyUnsavedPassword, ConnectionType.default, uri, true, connectionResult);
verifyShowFirewallRuleDialog(connectionProfile, false);
done();
}).catch(err => {
done(err);
});
});
test('connect when password is empty and saved should not open the dialog', done => {
test('connect when password is empty and saved should not open the dialog', () => {
let uri = undefined;
let expectedConnection: boolean = true;
let options: IConnectionCompletionOptions = {
@@ -648,17 +605,14 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: undefined
};
connect(uri, options, false, connectionProfileWithEmptySavedPassword).then(result => {
return connect(uri, options, false, connectionProfileWithEmptySavedPassword).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, connectionResult.errorMessage);
verifyShowConnectionDialog(connectionProfileWithEmptySavedPassword, ConnectionType.default, uri, true, connectionResult, false);
done();
}).catch(err => {
done(err);
});
});
test('connect from editor when empty password when it is required and saved should not open the dialog', done => {
test('connect from editor when empty password when it is required and saved should not open the dialog', () => {
let uri = 'editor 3';
let expectedConnection: boolean = true;
let options: IConnectionCompletionOptions = {
@@ -688,45 +642,36 @@ suite('SQL ConnectionManagementService tests', () => {
callStack: undefined
};
connect(uri, options, false, connectionProfileWithEmptySavedPassword).then(result => {
return connect(uri, options, false, connectionProfileWithEmptySavedPassword).then(result => {
assert.equal(result.connected, expectedConnection);
assert.equal(result.errorMessage, connectionResult.errorMessage);
verifyShowConnectionDialog(connectionProfileWithEmptySavedPassword, ConnectionType.editor, uri, true, connectionResult, false);
done();
}).catch(err => {
done(err);
});
});
test('doChangeLanguageFlavor should throw on unknown provider', done => {
test('doChangeLanguageFlavor should throw on unknown provider', () => {
// given a provider that will never exist
let invalidProvider = 'notaprovider';
// when I call doChangeLanguageFlavor
// Then I expect it to throw
assert.throws(() => connectionManagementService.doChangeLanguageFlavor('file://my.sql', 'sql', invalidProvider));
done();
});
test('doChangeLanguageFlavor should send event for known provider', done => {
test('doChangeLanguageFlavor should send event for known provider', () => {
// given a provider that is registered
let uri = 'file://my.sql';
let language = 'sql';
let flavor = 'MSSQL';
// when I call doChangeLanguageFlavor
try {
let called = false;
connectionManagementService.onLanguageFlavorChanged((changeParams: azdata.DidChangeLanguageFlavorParams) => {
called = true;
assert.equal(changeParams.uri, uri);
assert.equal(changeParams.language, language);
assert.equal(changeParams.flavor, flavor);
});
connectionManagementService.doChangeLanguageFlavor(uri, language, flavor);
assert.ok(called, 'expected onLanguageFlavorChanged event to be sent');
done();
} catch (error) {
done(error);
}
let called = false;
connectionManagementService.onLanguageFlavorChanged((changeParams: azdata.DidChangeLanguageFlavorParams) => {
called = true;
assert.equal(changeParams.uri, uri);
assert.equal(changeParams.language, language);
assert.equal(changeParams.flavor, flavor);
});
connectionManagementService.doChangeLanguageFlavor(uri, language, flavor);
assert.ok(called, 'expected onLanguageFlavorChanged event to be sent');
});
test('getUniqueConnectionProvidersByNameMap should return non CMS providers', () => {
@@ -744,7 +689,7 @@ suite('SQL ConnectionManagementService tests', () => {
assert.equal(providerNames[1], expectedNames[1]);
});
test('ensureDefaultLanguageFlavor should not send event if uri is connected', done => {
test('ensureDefaultLanguageFlavor should not send event if uri is connected', () => {
let uri: string = 'Editor Uri';
let options: IConnectionCompletionOptions = {
params: undefined,
@@ -758,16 +703,13 @@ suite('SQL ConnectionManagementService tests', () => {
connectionManagementService.onLanguageFlavorChanged((changeParams: azdata.DidChangeLanguageFlavorParams) => {
called = true;
});
connect(uri, options).then(() => {
return connect(uri, options).then(() => {
connectionManagementService.ensureDefaultLanguageFlavor(uri);
assert.equal(called, false, 'do not expect flavor change to be called');
done();
}).catch(err => {
done(err);
});
});
test('getConnectionId returns the URI associated with a connection that has had its database filled in', done => {
test('getConnectionId returns the URI associated with a connection that has had its database filled in', () => {
// Set up the connection management service with a connection corresponding to a default database
let dbName = 'master';
let serverName = 'test_server';
@@ -777,21 +719,16 @@ suite('SQL ConnectionManagementService tests', () => {
let connectionProfileWithDb: IConnectionProfile = assign(connectionProfileWithoutDb, { databaseName: dbName });
// Save the database with a URI that has the database name filled in, to mirror Carbon's behavior
let ownerUri = Utils.generateUri(connectionProfileWithDb);
connect(ownerUri, undefined, false, connectionProfileWithoutDb).then(() => {
try {
// If I get the URI for the connection with or without a database from the connection management service
let actualUriWithDb = connectionManagementService.getConnectionUri(connectionProfileWithDb);
let actualUriWithoutDb = connectionManagementService.getConnectionUri(connectionProfileWithoutDb);
return connect(ownerUri, undefined, false, connectionProfileWithoutDb).then(() => {
// If I get the URI for the connection with or without a database from the connection management service
let actualUriWithDb = connectionManagementService.getConnectionUri(connectionProfileWithDb);
let actualUriWithoutDb = connectionManagementService.getConnectionUri(connectionProfileWithoutDb);
// Then the retrieved URIs should match the one on the connection
let expectedUri = Utils.generateUri(connectionProfileWithoutDb);
assert.equal(actualUriWithDb, expectedUri);
assert.equal(actualUriWithoutDb, expectedUri);
done();
} catch (err) {
done(err);
}
}, err => done(err));
// Then the retrieved URIs should match the one on the connection
let expectedUri = Utils.generateUri(connectionProfileWithoutDb);
assert.equal(actualUriWithDb, expectedUri);
assert.equal(actualUriWithoutDb, expectedUri);
});
});
test('getTabColorForUri returns undefined when there is no connection for the given URI', () => {
@@ -800,7 +737,7 @@ suite('SQL ConnectionManagementService tests', () => {
assert.equal(color, undefined);
});
test('getTabColorForUri returns the group color corresponding to the connection for a URI', done => {
test('getTabColorForUri returns the group color corresponding to the connection for a URI', () => {
// Set up the connection store to give back a group for the expected connection profile
configResult['tabColorMode'] = 'border';
let expectedColor = 'red';
@@ -808,15 +745,10 @@ suite('SQL ConnectionManagementService tests', () => {
color: expectedColor
});
let uri = 'testUri';
connect(uri).then(() => {
try {
let tabColor = connectionManagementService.getTabColorForUri(uri);
assert.equal(tabColor, expectedColor);
done();
} catch (e) {
done(e);
}
}, err => done(err));
return connect(uri).then(() => {
let tabColor = connectionManagementService.getTabColorForUri(uri);
assert.equal(tabColor, expectedColor);
});
});
test('getActiveConnectionCredentials returns the credentials dictionary for a connection profile', () => {

9
src/sql/workbench/services/insights/test/electron-browser/insightsUtils.test.ts
View File

@@ -172,7 +172,7 @@ suite('Insights Utils tests', function () {
equal(resolvedPath, queryFilePath);
});
test('resolveQueryFilePath throws with workspaceRoot var and non-empty workspace not containing file', async (done) => {
test('resolveQueryFilePath throws with workspaceRoot var and non-empty workspace not containing file', async () => {
const tokenizedPath = path.join('${workspaceRoot}', 'test.sql');
// Create mock context service with a folder NOT containing our test file to verify it returns original path
const contextService = new TestContextService(
@@ -204,11 +204,10 @@ suite('Insights Utils tests', function () {
fail('Should have thrown');
}
catch (e) {
done();
}
});
test('resolveQueryFilePath throws with workspaceRoot var and empty workspace', async (done) => {
test('resolveQueryFilePath throws with workspaceRoot var and empty workspace', async () => {
const tokenizedPath = path.join('${workspaceRoot}', 'test.sql');
// Create mock context service with an empty workspace
const contextService = new TestContextService(
@@ -238,7 +237,6 @@ suite('Insights Utils tests', function () {
fail('Should have thrown');
}
catch (e) {
done();
}
});
@@ -298,7 +296,7 @@ suite('Insights Utils tests', function () {
equal(resolvedPath, queryFilePath);
});
test('resolveQueryFilePath throws if invalid param var specified', async (done) => {
test('resolveQueryFilePath throws if invalid param var specified', async () => {
const invalidPath = path.join('${INVALID}', 'test.sql');
const configurationResolverService = new ConfigurationResolverService(
undefined,
@@ -323,7 +321,6 @@ suite('Insights Utils tests', function () {
await instantiationService.invokeFunction(resolveQueryFilePath, invalidPath);
fail('Should have thrown');
} catch (e) {
done();
}
});

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

@@ -517,7 +517,7 @@ suite('SQL Object Explorer Service tests', () => {
assert.equal(isExpanded, false);
});
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', async () => {
const table1NodePath = objectExplorerExpandInfo.nodes[0].nodePath;
const tableExpandInfo = {
sessionId: sessionId,
@@ -530,26 +530,17 @@ suite('SQL Object Explorer Service tests', () => {
return treeNode.nodePath === table1NodePath;
});
objectExplorerService.registerServerTreeView(serverTreeView.object);
objectExplorerService.createNewSession(mssqlProviderName, connection).then(result => {
objectExplorerService.onSessionCreated(1, objectExplorerSession);
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection)).then(childNodes => {
sqlOEProvider.setup(x => x.expandNode(TypeMoq.It.isAny())).callback(() => {
objectExplorerService.onNodeExpanded(tableExpandInfo);
}).returns(() => Promise.resolve(true));
objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, find(childNodes, node => node.nodePath === table1NodePath)).then(() => {
// If I check whether the table is expanded, the answer should be yes
const tableNode = find(childNodes, node => node.nodePath === table1NodePath);
tableNode.isExpanded().then(isExpanded => {
try {
assert.equal(isExpanded, false);
done();
} catch (err) {
done(err);
}
}, err => done(err));
}, err => done(err));
}, err => done(err));
}, err => done(err));
await objectExplorerService.createNewSession(mssqlProviderName, connection);
objectExplorerService.onSessionCreated(1, objectExplorerSession);
const childNodes = await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, objectExplorerService.getObjectExplorerNode(connection));
sqlOEProvider.setup(x => x.expandNode(TypeMoq.It.isAny())).callback(() => {
objectExplorerService.onNodeExpanded(tableExpandInfo);
}).returns(() => Promise.resolve(true));
await objectExplorerService.resolveTreeNodeChildren(objectExplorerSession, find(childNodes, node => node.nodePath === table1NodePath));
// If I check whether the table is expanded, the answer should be yes
const tableNode = find(childNodes, node => node.nodePath === table1NodePath);
const isExpanded = await tableNode.isExpanded();
assert.equal(isExpanded, false);
});
test('setting a node to expanded calls expand on the requested tree node', async () => {

161
src/sql/workbench/test/electron-browser/api/extHostAccountManagement.test.ts
View File

@@ -101,25 +101,24 @@ suite('ExtHostAccountManagement', () => {
// TODO: Test for unregistering a provider
// CLEAR TESTS /////////////////////////////////////////////////////////
test('Clear - Success', (done) => {
test('Clear - Success', () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
extHost.$registerAccountProvider(mockAccountMetadata, mockProvider.object);
// If: I clear an account
extHost.$clear(0, mockAccount.key)
return extHost.$clear(0, mockAccount.key)
.then(() => {
// Then: The call should have been passed to the provider
mockProvider.verify(
(obj) => obj.clear(TypeMoq.It.isValue(mockAccount.key)),
TypeMoq.Times.once()
);
})
.then(() => done(), (err) => done(err));
});
});
test('Clear - Handle does not exist', (done) => {
test('Clear - Handle does not exist', async () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
@@ -127,38 +126,37 @@ suite('ExtHostAccountManagement', () => {
// If: I clear an account for a handle that doesn't exist
// Then: It should fail
extHost.$clear(1, mockAccount.key)
.then(() => done('Clear succeeded when it should have failed'))
.then(null, () => {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.clear(TypeMoq.It.isAny()),
TypeMoq.Times.never()
);
})
.then(() => done(), (err) => done(err));
try {
await extHost.$clear(1, mockAccount.key);
assert.fail('Clear succeeded when it should have failed');
} catch (e) {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.clear(TypeMoq.It.isAny()),
TypeMoq.Times.never()
);
}
});
// INITIALIZE TESTS ////////////////////////////////////////////////////
test('Initialize - Success', (done) => {
test('Initialize - Success', () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
extHost.$registerAccountProvider(mockAccountMetadata, mockProvider.object);
// If: I initialize the provider
extHost.$initialize(0, [mockAccount])
return extHost.$initialize(0, [mockAccount])
.then(() => {
// Then: The call should have been passed to the provider
mockProvider.verify(
(obj) => obj.initialize(TypeMoq.It.isValue([mockAccount])),
TypeMoq.Times.once()
);
})
.then(() => done(), (err) => done(err));
});
});
test('Initialize - Handle does not exist', (done) => {
test('Initialize - Handle does not exist', async () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
@@ -166,38 +164,37 @@ suite('ExtHostAccountManagement', () => {
// If: I initialize for a handle that doesn't exist
// Then: It should fail
extHost.$initialize(1, [mockAccount])
.then(() => done('Initialize succeeded when it should have failed'))
.then(null, () => {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.initialize(TypeMoq.It.isAny()),
TypeMoq.Times.never()
);
})
.then(() => done(), (err) => done(err));
try {
await extHost.$initialize(1, [mockAccount]);
assert.fail('Initialize succeeded when it should have failed');
} catch (e) {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.initialize(TypeMoq.It.isAny()),
TypeMoq.Times.never()
);
}
});
// PROMPT TESTS ////////////////////////////////////////////////////////
test('Prompt - Success', (done) => {
test('Prompt - Success', () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
extHost.$registerAccountProvider(mockAccountMetadata, mockProvider.object);
// If: I prompt for an account
extHost.$prompt(0)
return extHost.$prompt(0)
.then(() => {
// Then: The call should have been passed to the provider
mockProvider.verify(
(obj) => obj.prompt(),
TypeMoq.Times.once()
);
})
.then(() => done(), (err) => done(err));
});
});
test('Prompt - Handle does not exist', (done) => {
test('Prompt - Handle does not exist', async () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
@@ -205,38 +202,37 @@ suite('ExtHostAccountManagement', () => {
// If: I prompt with a handle that doesn't exist
// Then: It should fail
extHost.$prompt(1)
.then(() => done('Prompt succeeded when it should have failed'))
.then(null, () => {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.prompt(),
TypeMoq.Times.never()
);
})
.then(() => done(), (err) => done(err));
try {
await extHost.$prompt(1);
assert.fail('Prompt succeeded when it should have failed');
} catch (e) {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.prompt(),
TypeMoq.Times.never()
);
}
});
// REFRESH TESTS ///////////////////////////////////////////////////////
test('Refresh - Success', (done) => {
test('Refresh - Success', () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
extHost.$registerAccountProvider(mockAccountMetadata, mockProvider.object);
// If: I refresh an account
extHost.$refresh(0, mockAccount)
return extHost.$refresh(0, mockAccount)
.then(() => {
// Then: The call should have been passed to the provider
mockProvider.verify(
(obj) => obj.refresh(TypeMoq.It.isValue(mockAccount)),
TypeMoq.Times.once()
);
})
.then(() => done(), (err) => done(err));
});
});
test('Refresh - Handle does not exist', (done) => {
test('Refresh - Handle does not exist', async () => {
// Setup: Create ext host account management with registered account provider
let extHost = new ExtHostAccountManagement(threadService);
let mockProvider = getMockAccountProvider();
@@ -244,20 +240,20 @@ suite('ExtHostAccountManagement', () => {
// If: I refresh an account for a handle that doesn't exist
// Then: It should fail
extHost.$refresh(1, mockAccount)
.then(() => done('Refresh succeeded when it should have failed'))
.then(null, () => {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.refresh(TypeMoq.It.isAny()),
TypeMoq.Times.never()
);
})
.then(() => done(), (err) => done(err));
try {
await extHost.$refresh(1, mockAccount);
assert.fail('Refresh succeeded when it should have failed');
} catch (e) {
// The provider's clear should not have been called
mockProvider.verify(
(obj) => obj.refresh(TypeMoq.It.isAny()),
TypeMoq.Times.never()
);
}
});
// GETALLACCOUNTS TESTS ///////////////////////////////////////////////////////
test('GetAllAccounts - Success', (done) => {
test('GetAllAccounts - Success', () => {
let mockAccountProviderMetadata = {
id: 'azure',
displayName: 'Azure'
@@ -305,7 +301,7 @@ suite('ExtHostAccountManagement', () => {
extHost.$registerAccountProvider(mockAccountProviderMetadata, new AccountProviderStub());
// If: I get all accounts
extHost.$getAllAccounts()
return extHost.$getAllAccounts()
.then((accounts) => {
// Then: The call should have been passed to the account management service
mockAccountManagementService.verify(
@@ -316,25 +312,24 @@ suite('ExtHostAccountManagement', () => {
assert.ok(Array.isArray(accounts));
assert.equal(accounts.length, expectedAccounts.length);
assert.deepStrictEqual(accounts, expectedAccounts);
})
.then(() => done(), (err) => done(err));
});
});
test('GetAllAccounts - No account providers', (done) => {
test('GetAllAccounts - No account providers', async () => {
// Setup: Create ext host account management with no registered account providers
let extHost = new ExtHostAccountManagement(threadService);
// If: I get all accounts
// Then: It should throw
assert.throws(
() => extHost.$getAllAccounts(),
(error) => {
return error.message === 'No account providers registered.';
});
done();
try {
await extHost.$getAllAccounts();
assert.fail('Succedded when should have failed');
} catch (e) {
assert(e.message === 'No account providers registered.');
}
});
test('GetSecurityToken - Success', (done) => {
test('GetSecurityToken - Success', () => {
let mockAccountProviderMetadata = {
id: 'azure',
displayName: 'Azure'
@@ -365,15 +360,14 @@ suite('ExtHostAccountManagement', () => {
let extHost = new ExtHostAccountManagement(threadService);
extHost.$registerAccountProvider(mockAccountProviderMetadata, new AccountProviderStub());
extHost.$getAllAccounts()
return extHost.$getAllAccounts()
.then((accounts) => {
// If: I get security token it will not throw
return extHost.$getSecurityToken(mockAccount1, AzureResource.ResourceManagement);
}
).then(() => done(), (err) => done(new Error(err)));
});
});
test('GetSecurityToken - Account not found', (done) => {
test('GetSecurityToken - Account not found', async () => {
let mockAccountProviderMetadata = {
id: 'azure',
displayName: 'Azure'
@@ -419,16 +413,11 @@ suite('ExtHostAccountManagement', () => {
isStale: false
};
extHost.$getAllAccounts()
.then(accounts => {
return extHost.$getSecurityToken(mockAccount2, AzureResource.ResourceManagement);
})
.then((noError) => {
done(new Error('Expected getSecurityToken to throw'));
}, (err) => {
// Expected error caught
done();
});
await extHost.$getAllAccounts();
try {
await extHost.$getSecurityToken(mockAccount2, AzureResource.ResourceManagement);
assert.fail('Expected getSecurityToken to throw');
} catch (e) { }
});
});

38
src/sql/workbench/test/electron-browser/api/extHostCredentialManagement.test.ts
View File

@@ -56,7 +56,7 @@ suite('ExtHostCredentialManagement', () => {
assert.equal(extHost.getProviderCount(), 1);
});
test('Get Credential Provider - Success', (done) => {
test('Get Credential Provider - Success', () => {
// Setup: Register a mock credential provider
let extHost = new ExtHostCredentialManagement(threadService);
let mockCredentialProvider = new TestCredentialsProvider();
@@ -68,7 +68,7 @@ suite('ExtHostCredentialManagement', () => {
let credential = 'test_credential';
let expectedCredentialId = `${namespaceId}|${credentialId}`;
let credProvider: CredentialProvider;
extHost.$getCredentialProvider(namespaceId)
return extHost.$getCredentialProvider(namespaceId)
.then((provider) => {
// Then: There should still only be one provider registered
assert.equal(extHost.getProviderCount(), 1);
@@ -100,11 +100,10 @@ suite('ExtHostCredentialManagement', () => {
.then(() => {
// Then: The credential with its namespace should no longer exist
assert.strictEqual(mockCredentialProvider.storedCredentials[expectedCredentialId], undefined);
})
.then(() => done(), (err) => done(err));
});
});
test('Get Credential Provider - No Namespace', (done) => {
test('Get Credential Provider - No Namespace', async () => {
// Setup: Register a mock credential provider
let extHost = new ExtHostCredentialManagement(threadService);
let mockCredentialProvider = new TestCredentialsProvider();
@@ -112,20 +111,19 @@ suite('ExtHostCredentialManagement', () => {
// If: I get a credential provider with an invalid namespace ID
// Then: I should get an error
extHost.$getCredentialProvider(undefined)
.then(
() => { done('Provider was returned from undefined'); },
() => { /* Swallow error, this is success path */ }
)
.then(() => { return extHost.$getCredentialProvider(null); })
.then(
() => { done('Provider was returned from null'); },
() => { /* Swallow error, this is success path */ }
)
.then(() => { return extHost.$getCredentialProvider(''); })
.then(
() => { done('Provider was returned from \'\''); },
() => { done(); }
);
try {
await extHost.$getCredentialProvider(undefined);
assert.fail('Provider was returned from undefined');
} catch (e) { }
try {
await extHost.$getCredentialProvider(null);
assert.fail('Provider was returned from null');
} catch (e) { }
try {
await extHost.$getCredentialProvider('');
assert.fail('Provider was returned from \'\'');
} catch (e) { }
});
});

39
src/sql/workbench/test/electron-browser/api/extHostModelView.test.ts
View File

@@ -77,44 +77,29 @@ suite('ExtHostModelView Validation Tests', () => {
extHostModelView.$registerWidget(handle, widgetId, undefined, undefined);
});
test('The custom validation output of a component gets set when it is initialized', done => {
extHostModelView.$runCustomValidations(handle, inputBox.id).then(valid => {
try {
assert.equal(valid, false, 'Empty input box did not validate as false');
done();
} catch (err) {
done(err);
}
}, err => done(err));
test('The custom validation output of a component gets set when it is initialized', () => {
return extHostModelView.$runCustomValidations(handle, inputBox.id).then(valid => {
assert.equal(valid, false, 'Empty input box did not validate as false');
});
});
test('The custom validation output of a component changes if its value changes', done => {
test('The custom validation output of a component changes if its value changes', () => {
inputBox.value = validText;
extHostModelView.$runCustomValidations(handle, inputBox.id).then(valid => {
try {
assert.equal(valid, true, 'Valid input box did not validate as valid');
done();
} catch (err) {
done(err);
}
}, err => done(err));
return extHostModelView.$runCustomValidations(handle, inputBox.id).then(valid => {
assert.equal(valid, true, 'Valid input box did not validate as valid');
});
});
test('The custom validation output of a component changes after a PropertiesChanged event', done => {
test('The custom validation output of a component changes after a PropertiesChanged event', () => {
extHostModelView.$handleEvent(handle, inputBox.id, {
args: {
'value': validText
},
eventType: ComponentEventType.PropertiesChanged
} as IComponentEventArgs);
extHostModelView.$runCustomValidations(handle, inputBox.id).then(valid => {
try {
assert.equal(valid, true, 'Valid input box did not validate as valid after PropertiesChanged event');
done();
} catch (err) {
done(err);
}
}, err => done(err));
return extHostModelView.$runCustomValidations(handle, inputBox.id).then(valid => {
assert.equal(valid, true, 'Valid input box did not validate as valid after PropertiesChanged event');
});
});
test('The validity of a component is set by main thread validationChanged events', () => {

6
src/sql/workbench/test/electron-browser/api/exthostNotebook.test.ts
View File

@@ -13,7 +13,6 @@ import { IMainContext } from 'vs/workbench/api/common/extHost.protocol';
import { ExtHostNotebook } from 'sql/workbench/api/common/extHostNotebook';
import { MainThreadNotebookShape } from 'sql/workbench/api/common/sqlExtHost.protocol';
import * as testUtils from '../../../../base/test/common/async';
import { INotebookManagerDetails } from 'sql/workbench/api/common/sqlExtHostTypes';
import { mssqlProviderName } from 'sql/platform/connection/common/constants';
@@ -40,7 +39,10 @@ suite('ExtHostNotebook Tests', () => {
suite('getNotebookManager', () => {
test('Should throw if no matching provider is defined', async () => {
await testUtils.assertThrowsAsync(() => extHostNotebook.$getNotebookManager(-1, notebookUri));
try {
await extHostNotebook.$getNotebookManager(-1, notebookUri);
assert.fail('expected to throw');
} catch (e) { }
});
suite('with provider', () => {
let providerHandle: number = -1;

45
src/sql/workbench/test/electron-browser/modalComponents/componentBase.test.ts
View File

@@ -64,7 +64,7 @@ suite('ComponentBase Tests', () => {
testContainer = new TestContainer(modelStore, 'testContainer');
});
test('Component validation runs external validations stored in the model store', done => {
test('Component validation runs external validations stored in the model store', () => {
assert.equal(testComponent.valid, true, 'Test component validity did not default to true');
let validationCalls = 0;
modelStore.registerValidationCallback(componentId => {
@@ -72,19 +72,14 @@ suite('ComponentBase Tests', () => {
return Promise.resolve(false);
});
testComponent.validate().then(valid => {
try {
assert.equal(validationCalls, 1, 'External validation was not called once');
assert.equal(valid, false, 'Validate call did not return correct value from the external validation');
assert.equal(testComponent.valid, false, 'Validate call did not update the component valid property');
done();
} catch (err) {
done(err);
}
}, err => done(err));
return testComponent.validate().then(valid => {
assert.equal(validationCalls, 1, 'External validation was not called once');
assert.equal(valid, false, 'Validate call did not return correct value from the external validation');
assert.equal(testComponent.valid, false, 'Validate call did not update the component valid property');
});
});
test('Component validation runs default component validations', done => {
test('Component validation runs default component validations', () => {
assert.equal(testComponent.valid, true, 'Test component validity did not default to true');
let validationCalls = 0;
testComponent.addValidation(() => {
@@ -92,29 +87,23 @@ suite('ComponentBase Tests', () => {
return false;
});
testComponent.validate().then(valid => {
try {
assert.equal(validationCalls, 1, 'Default validation was not called once');
assert.equal(valid, false, 'Validate call did not return correct value from the default validation');
assert.equal(testComponent.valid, false, 'Validate call did not update the component valid property');
done();
} catch (err) {
done(err);
}
}, err => done(err));
return testComponent.validate().then(valid => {
assert.equal(validationCalls, 1, 'Default validation was not called once');
assert.equal(valid, false, 'Validate call did not return correct value from the default validation');
assert.equal(testComponent.valid, false, 'Validate call did not update the component valid property');
});
});
test('Container validation reflects child component validity', done => {
test('Container validation reflects child component validity', () => {
assert.equal(testContainer.valid, true, 'Test container validity did not default to true');
testContainer.addToContainer(testComponent.descriptor, undefined);
testComponent.addValidation(() => false);
testComponent.validate().then(() => {
testContainer.validate().then(valid => {
return testComponent.validate().then(() => {
return testContainer.validate().then(valid => {
assert.equal(valid, false, 'Validate call did not return correct value for container child validation');
assert.equal(testContainer.valid, false, 'Validate call did not update the container valid property');
done();
}, err => done(err));
}, err => done(err));
});
});
});
test('Container child validity changes cause the parent container validity to change', done => {

28
test/all.js
View File

@@ -10,9 +10,11 @@ const assert = require('assert');
const path = require('path');
const glob = require('glob');
const jsdom = require('jsdom-no-contextify');
const TEST_GLOB = '**/test/**/*.test.js|**/sqltest/**/*.test.js';
const TEST_GLOB = '**/test/**/*.test.js';
const coverage = require('./coverage');
require('reflect-metadata'); // {{SQL CARBON EDIT}}
var optimist = require('optimist')
.usage('Run the Code tests. All mocha options apply.')
.describe('build', 'Run from out-build').boolean('build')
@@ -39,7 +41,6 @@ function main() {
console.error(e.stack || e);
});
// {{SQL CARBON EDIT}}
var loaderConfig = {
nodeRequire: require,
nodeMain: __filename,
@@ -47,14 +48,12 @@ function main() {
paths: {
'vs/css': '../test/css.mock',
'vs': `../${out}/vs`,
'sqltest': `../${out}/sqltest`,
'sql': `../${out}/sql`,
'sql': `../${out}/sql`, // {{SQL CARBON EDIT}}
'lib': `../${out}/lib`,
'bootstrap-fork': `../${out}/bootstrap-fork`
},
catchError: true,
// {{SQL CARBON EDIT}}
nodeModules: [
nodeModules: [ // {{SQL CARBON EDIT}}
'@angular/common',
'@angular/core',
'@angular/forms',
@@ -92,12 +91,6 @@ function main() {
global.Node = global.window.Node;
global.navigator = global.window.navigator;
global.XMLHttpRequest = global.window.XMLHttpRequest;
// {{SQL CARBON EDIT}}
global.Event = global.window.Event;
require('reflect-metadata');
global.window.Reflect = global.Reflect;
global.window.Zone = global.Zone;
var didErr = false;
var write = process.stderr.write;
@@ -183,8 +176,6 @@ function main() {
});
}
// {{SQL CARBON EDIT}}
/*
// report failing test for every unexpected error during any of the tests
var unexpectedErrors = [];
suite('Errors', function () {
@@ -199,15 +190,16 @@ function main() {
}
});
});
// {{SQL CARBON EDIT}}
*/
// replace the default unexpected error handler to be useful during tests
loader(['vs/base/common/errors'], function (errors) {
global.window.addEventListener('unhandledrejection', event => {
errors.onUnexpectedError(event.reason);
event.preventDefault();
});
errors.setUnexpectedErrorHandler(function (err) {
let stack = (err && err.stack) || (new Error().stack);
// {{SQL CARBON EDIT}}
//unexpectedErrors.push((err && err.message ? err.message : err) + '\n' + stack);
unexpectedErrors.push((err && err.message ? err.message : err) + '\n' + stack);
});
// fire up mocha

6
test/electron/renderer.js
View File

@@ -37,7 +37,6 @@ function initLoader(opts) {
baseUrl: bootstrap.uriFromPath(path.join(__dirname, '../../src')),
paths: {
'vs': `../${outdir}/vs`,
'sqltest': `../${outdir}/sqltest`, // {{SQL CARBON EDIT}}
'sql': `../${outdir}/sql`, // {{SQL CARBON EDIT}}
'lib': `../${outdir}/lib`,
'bootstrap-fork': `../${outdir}/bootstrap-fork`
@@ -120,6 +119,11 @@ function loadTests(opts) {
// collect unexpected errors
loader.require(['vs/base/common/errors'], function (errors) {
global.window.addEventListener('unhandledrejection', event => {
errors.onUnexpectedError(event.reason);
event.preventDefault();
});
errors.setUnexpectedErrorHandler(function (err) {
let stack = (err ? err.stack : null);
if (!stack) {