mirror of
https://github.com/ckaczor/azuredatastudio.git
synced 2026-01-30 17:23:29 -05:00
ef57812a95
* Enables being able to view and edit Coordinator node scheduling params (#15114) * Trying to save per role settings * Updated spec * Cleaning up * Removed unneccessary code and comments * Added separate type for { w?: string, c?: string}, PR fixes * Added methods to refresh mr,ml,cr,cl versus per role * Fixed spec * Put back optional properties, removed passing empty string to reset scheduling params * Spacing * vBump arc * Included roles in fake show output for testing (#15196) * Update arc specs (#15225) * Update azdata Arc specs to match April azdata * vcores -> cpu * fix spacing * Consolidate types and update storage volumes * Fix compile * Update min azdata version Co-authored-by: nasc17 <69922333+nasc17@users.noreply.github.com> Co-authored-by: nasc17 <nasc@microsoft.com>
585 lines
24 KiB
TypeScript
585 lines
24 KiB
TypeScript
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
|
|
import { PGResourceInfo, ResourceType } from 'arc';
|
|
import * as azdataExt from 'azdata-ext';
|
|
import * as azdata from 'azdata';
|
|
import * as should from 'should';
|
|
import * as sinon from 'sinon';
|
|
import * as TypeMoq from 'typemoq';
|
|
import * as vscode from 'vscode';
|
|
import { generateGuid } from '../../common/utils';
|
|
import { UserCancelledError } from '../../common/api';
|
|
import { ControllerModel, Registration } from '../../models/controllerModel';
|
|
import { PostgresModel, EngineSettingsModel } from '../../models/postgresModel';
|
|
import { ConnectToPGSqlDialog } from '../../ui/dialogs/connectPGDialog';
|
|
import { AzureArcTreeDataProvider } from '../../ui/tree/azureArcTreeDataProvider';
|
|
import { FakeControllerModel } from '../mocks/fakeControllerModel';
|
|
import { FakeAzdataApi } from '../mocks/fakeAzdataApi';
|
|
|
|
export const FakePostgresServerShowOutput: azdataExt.AzdataOutput<azdataExt.PostgresServerShowResult> = {
|
|
logs: [],
|
|
stdout: [],
|
|
stderr: [],
|
|
result: {
|
|
apiVersion: 'version',
|
|
kind: 'postgresql',
|
|
metadata: {
|
|
creationTimestamp: '',
|
|
generation: 1,
|
|
name: 'pgt',
|
|
namespace: 'ns',
|
|
resourceVersion: '',
|
|
selfLink: '',
|
|
uid: '',
|
|
},
|
|
spec: {
|
|
engine: {
|
|
extensions: [{ name: '' }],
|
|
settings: {
|
|
default: { ['']: '' }
|
|
},
|
|
version: ''
|
|
},
|
|
scale: {
|
|
shards: 0,
|
|
workers: 0
|
|
},
|
|
scheduling: {
|
|
default: {
|
|
resources: {
|
|
requests: {
|
|
cpu: '',
|
|
memory: ''
|
|
},
|
|
limits: {
|
|
cpu: '',
|
|
memory: ''
|
|
}
|
|
}
|
|
},
|
|
roles: {
|
|
coordinator: {
|
|
resources: {
|
|
requests: {
|
|
cpu: '',
|
|
memory: ''
|
|
},
|
|
limits: {
|
|
cpu: '',
|
|
memory: ''
|
|
}
|
|
}
|
|
},
|
|
worker: {
|
|
resources: {
|
|
requests: {
|
|
cpu: '',
|
|
memory: ''
|
|
},
|
|
limits: {
|
|
cpu: '',
|
|
memory: ''
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
services: {
|
|
primary: {
|
|
type: '',
|
|
port: 0
|
|
}
|
|
},
|
|
storage: {
|
|
data: {
|
|
volumes: [
|
|
{
|
|
className: '',
|
|
size: ''
|
|
}
|
|
]
|
|
},
|
|
logs: {
|
|
volumes: [
|
|
{
|
|
className: '',
|
|
size: ''
|
|
}
|
|
]
|
|
},
|
|
backups: {
|
|
volumes: [
|
|
{
|
|
className: '',
|
|
size: ''
|
|
}
|
|
]
|
|
}
|
|
}
|
|
},
|
|
status: {
|
|
primaryEndpoint: '127.0.0.1:5432',
|
|
readyPods: '',
|
|
state: '',
|
|
logSearchDashboard: '',
|
|
metricsDashboard: '',
|
|
podsStatus: [{
|
|
conditions: [{
|
|
lastTransitionTime: '',
|
|
message: '',
|
|
reason: '',
|
|
status: '',
|
|
type: '',
|
|
}],
|
|
name: '',
|
|
role: '',
|
|
}]
|
|
}
|
|
}
|
|
};
|
|
|
|
describe('PostgresModel', function (): void {
|
|
let controllerModel: ControllerModel;
|
|
let postgresModel: PostgresModel;
|
|
let azdataApi: azdataExt.IAzdataApi;
|
|
|
|
afterEach(function (): void {
|
|
sinon.restore();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
// Setup Controller Model
|
|
controllerModel = new FakeControllerModel();
|
|
|
|
//Stub calling azdata login and acquiring session
|
|
sinon.stub(controllerModel, 'login').returns(Promise.resolve());
|
|
|
|
// Stub the azdata CLI API
|
|
azdataApi = new FakeAzdataApi();
|
|
const azdataExt = TypeMoq.Mock.ofType<azdataExt.IExtension>();
|
|
azdataExt.setup(x => x.azdata).returns(() => azdataApi);
|
|
sinon.stub(vscode.extensions, 'getExtension').returns(<any>{ exports: azdataExt.object });
|
|
});
|
|
|
|
describe('refresh', function (): void {
|
|
|
|
beforeEach(async () => {
|
|
// Setup PostgresModel
|
|
const postgresResource: PGResourceInfo = { name: 'pgt', resourceType: '' };
|
|
const registration: Registration = { instanceName: '', state: '', instanceType: ResourceType.postgresInstances };
|
|
postgresModel = new PostgresModel(controllerModel, postgresResource, registration, new AzureArcTreeDataProvider(TypeMoq.Mock.ofType<vscode.ExtensionContext>().object));
|
|
});
|
|
|
|
it('Updates model to expected config', async function (): Promise<void> {
|
|
const postgresShowStub = sinon.stub(azdataApi.arc.postgres.server, 'show').resolves(FakePostgresServerShowOutput);
|
|
|
|
await postgresModel.refresh();
|
|
sinon.assert.calledOnceWithExactly(postgresShowStub, postgresModel.info.name, sinon.match.any, sinon.match.any);
|
|
sinon.assert.match(postgresModel.config, FakePostgresServerShowOutput.result);
|
|
});
|
|
|
|
it('Updates onConfigLastUpdated when model is refreshed', async function (): Promise<void> {
|
|
const postgresShowStub = sinon.stub(azdataApi.arc.postgres.server, 'show').resolves(FakePostgresServerShowOutput);
|
|
|
|
await postgresModel.refresh();
|
|
sinon.assert.calledOnceWithExactly(postgresShowStub, postgresModel.info.name, sinon.match.any, sinon.match.any);
|
|
should(postgresModel.configLastUpdated).be.Date();
|
|
});
|
|
|
|
it('Calls onConfigUpdated event when model is refreshed', async function (): Promise<void> {
|
|
const postgresShowStub = sinon.stub(azdataApi.arc.postgres.server, 'show').resolves(FakePostgresServerShowOutput);
|
|
const configUpdatedEvent = sinon.spy(vscode.EventEmitter.prototype, 'fire');
|
|
|
|
await postgresModel.refresh();
|
|
sinon.assert.calledOnceWithExactly(postgresShowStub, postgresModel.info.name, sinon.match.any, sinon.match.any);
|
|
sinon.assert.calledOnceWithExactly(configUpdatedEvent, postgresModel.config);
|
|
});
|
|
|
|
it('Expected exception is thrown', async function (): Promise<void> {
|
|
// Stub 'azdata arc postgres server show' to throw an exception
|
|
const error = new Error('something bad happened');
|
|
sinon.stub(azdataApi.arc.postgres.server, 'show').throws(error);
|
|
|
|
await should(postgresModel.refresh()).be.rejectedWith(error);
|
|
});
|
|
});
|
|
|
|
describe('getConnectionProfile', function (): void {
|
|
|
|
beforeEach(async () => {
|
|
// Setup PostgresModel
|
|
const postgresResource: PGResourceInfo = { name: 'pgt', resourceType: '', userName: 'postgres', connectionId: '12345678' };
|
|
const registration: Registration = { instanceName: '', state: '', instanceType: ResourceType.postgresInstances };
|
|
postgresModel = new PostgresModel(controllerModel, postgresResource, registration, new AzureArcTreeDataProvider(TypeMoq.Mock.ofType<vscode.ExtensionContext>().object));
|
|
|
|
sinon.stub(azdataApi.arc.postgres.server, 'show').resolves(FakePostgresServerShowOutput);
|
|
|
|
//Call to provide external endpoint
|
|
await postgresModel.refresh();
|
|
});
|
|
|
|
it('Rejected with expected error when user cancels', async function (): Promise<void> {
|
|
const close = sinon.stub(ConnectToPGSqlDialog.prototype, 'waitForClose').returns(Promise.resolve(undefined));
|
|
await should(postgresModel['getConnectionProfile']()).be.rejectedWith(new UserCancelledError());
|
|
sinon.assert.calledOnce(close);
|
|
});
|
|
|
|
it('Show dialog prompt if password not found', async function (): Promise<void> {
|
|
const connect = sinon.stub(azdata.connection, 'connect');
|
|
|
|
const cancelButtonMock = TypeMoq.Mock.ofType<azdata.window.Button>();
|
|
cancelButtonMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const dialogMock = TypeMoq.Mock.ofType<azdata.window.Dialog>();
|
|
dialogMock.setup(x => x.cancelButton).returns(() => cancelButtonMock.object);
|
|
dialogMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const show = sinon.stub(azdata.window, 'createModelViewDialog').returns(dialogMock.object);
|
|
sinon.stub(azdata.window, 'openDialog');
|
|
|
|
const iconnectionProfileMock = TypeMoq.Mock.ofType<azdata.IConnectionProfile>();
|
|
iconnectionProfileMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const close = sinon.stub(ConnectToPGSqlDialog.prototype, 'waitForClose').returns(Promise.resolve(iconnectionProfileMock.object));
|
|
|
|
await postgresModel['getConnectionProfile']();
|
|
sinon.assert.notCalled(connect);
|
|
sinon.assert.calledOnce(show);
|
|
sinon.assert.calledOnce(close);
|
|
});
|
|
|
|
it('Reads password from cred store and no dialog prompt', async function (): Promise<void> {
|
|
const password = generateGuid();
|
|
// Set up cred store to return our password
|
|
const credProviderMock = TypeMoq.Mock.ofType<azdata.CredentialProvider>();
|
|
credProviderMock.setup(x => x.readCredential(TypeMoq.It.isAny())).returns(() => Promise.resolve({ credentialId: 'id', password: password }));
|
|
credProviderMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.credentials, 'getProvider').returns(Promise.resolve(credProviderMock.object));
|
|
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => true);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const connect = sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
const cancelButtonMock = TypeMoq.Mock.ofType<azdata.window.Button>();
|
|
cancelButtonMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const dialogMock = TypeMoq.Mock.ofType<azdata.window.Dialog>();
|
|
dialogMock.setup(x => x.cancelButton).returns(() => cancelButtonMock.object);
|
|
dialogMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const show = sinon.stub(azdata.window, 'createModelViewDialog').returns(dialogMock.object);
|
|
sinon.stub(azdata.window, 'openDialog');
|
|
|
|
const treeSave = sinon.spy(AzureArcTreeDataProvider.prototype, 'saveControllers');
|
|
|
|
await postgresModel['getConnectionProfile']();
|
|
sinon.assert.calledOnce(connect);
|
|
sinon.assert.notCalled(show);
|
|
sinon.assert.calledOnce(treeSave);
|
|
});
|
|
|
|
it('Reads password from cred store and connect fails, show dialog prompt', async function (): Promise<void> {
|
|
const password = generateGuid();
|
|
// Set up cred store to return our password
|
|
const credProviderMock = TypeMoq.Mock.ofType<azdata.CredentialProvider>();
|
|
credProviderMock.setup(x => x.readCredential(TypeMoq.It.isAny())).returns(() => Promise.resolve({ credentialId: 'id', password: password }));
|
|
credProviderMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.credentials, 'getProvider').returns(Promise.resolve(credProviderMock.object));
|
|
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => false);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const connect = sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
const iconnectionProfileMock = TypeMoq.Mock.ofType<azdata.IConnectionProfile>();
|
|
iconnectionProfileMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const close = sinon.stub(ConnectToPGSqlDialog.prototype, 'waitForClose').returns(Promise.resolve(iconnectionProfileMock.object));
|
|
|
|
const cancelButtonMock = TypeMoq.Mock.ofType<azdata.window.Button>();
|
|
cancelButtonMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const dialogMock = TypeMoq.Mock.ofType<azdata.window.Dialog>();
|
|
dialogMock.setup(x => x.cancelButton).returns(() => cancelButtonMock.object);
|
|
dialogMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const show = sinon.stub(azdata.window, 'createModelViewDialog').returns(dialogMock.object);
|
|
sinon.stub(azdata.window, 'openDialog');
|
|
|
|
await postgresModel['getConnectionProfile']();
|
|
sinon.assert.calledOnce(connect);
|
|
sinon.assert.calledOnce(show);
|
|
sinon.assert.calledOnce(close);
|
|
});
|
|
|
|
it('Show dialog prompt if username not found', async function (): Promise<void> {
|
|
// Setup PostgresModel without username
|
|
const postgresResource: PGResourceInfo = { name: 'pgt', resourceType: '', connectionId: '12345678' };
|
|
const registration: Registration = { instanceName: '', state: '', instanceType: ResourceType.postgresInstances };
|
|
let postgresModelNew = new PostgresModel(controllerModel, postgresResource, registration, new AzureArcTreeDataProvider(TypeMoq.Mock.ofType<vscode.ExtensionContext>().object));
|
|
await postgresModelNew.refresh();
|
|
|
|
const password = generateGuid();
|
|
// Set up cred store to return our password
|
|
const credProviderMock = TypeMoq.Mock.ofType<azdata.CredentialProvider>();
|
|
credProviderMock.setup(x => x.readCredential(TypeMoq.It.isAny())).returns(() => Promise.resolve({ credentialId: 'id', password: password }));
|
|
credProviderMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.credentials, 'getProvider').returns(Promise.resolve(credProviderMock.object));
|
|
|
|
const connect = sinon.stub(azdata.connection, 'connect');
|
|
const cancelButtonMock = TypeMoq.Mock.ofType<azdata.window.Button>();
|
|
cancelButtonMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const dialogMock = TypeMoq.Mock.ofType<azdata.window.Dialog>();
|
|
dialogMock.setup(x => x.cancelButton).returns(() => cancelButtonMock.object);
|
|
dialogMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const show = sinon.stub(azdata.window, 'createModelViewDialog').returns(dialogMock.object);
|
|
sinon.stub(azdata.window, 'openDialog');
|
|
|
|
const iconnectionProfileMock = TypeMoq.Mock.ofType<azdata.IConnectionProfile>();
|
|
iconnectionProfileMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const close = sinon.stub(ConnectToPGSqlDialog.prototype, 'waitForClose').returns(Promise.resolve(iconnectionProfileMock.object));
|
|
|
|
await postgresModelNew['getConnectionProfile']();
|
|
sinon.assert.notCalled(connect);
|
|
sinon.assert.calledOnce(show);
|
|
sinon.assert.calledOnce(close);
|
|
});
|
|
|
|
it('Shows dialog prompt if no connection id', async function (): Promise<void> {
|
|
// Setup PostgresModel without connectionId
|
|
const postgresResource: PGResourceInfo = { name: 'pgt', resourceType: '' };
|
|
const registration: Registration = { instanceName: '', state: '', instanceType: ResourceType.postgresInstances };
|
|
let postgresModelNew = new PostgresModel(controllerModel, postgresResource, registration, new AzureArcTreeDataProvider(TypeMoq.Mock.ofType<vscode.ExtensionContext>().object));
|
|
await postgresModelNew.refresh();
|
|
|
|
const provider = sinon.stub(azdata.credentials, 'getProvider');
|
|
const connect = sinon.stub(azdata.connection, 'connect');
|
|
const cancelButtonMock = TypeMoq.Mock.ofType<azdata.window.Button>();
|
|
cancelButtonMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const dialogMock = TypeMoq.Mock.ofType<azdata.window.Dialog>();
|
|
dialogMock.setup(x => x.cancelButton).returns(() => cancelButtonMock.object);
|
|
dialogMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const show = sinon.stub(azdata.window, 'createModelViewDialog').returns(dialogMock.object);
|
|
sinon.stub(azdata.window, 'openDialog');
|
|
|
|
const iconnectionProfileMock = TypeMoq.Mock.ofType<azdata.IConnectionProfile>();
|
|
iconnectionProfileMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const close = sinon.stub(ConnectToPGSqlDialog.prototype, 'waitForClose').returns(Promise.resolve(iconnectionProfileMock.object));
|
|
|
|
await postgresModelNew['getConnectionProfile']();
|
|
sinon.assert.notCalled(provider);
|
|
sinon.assert.notCalled(connect);
|
|
sinon.assert.calledOnce(show);
|
|
sinon.assert.calledOnce(close);
|
|
});
|
|
});
|
|
|
|
describe('getEngineSettings', function (): void {
|
|
|
|
beforeEach(async () => {
|
|
// Setup PostgresModel
|
|
const postgresResource: PGResourceInfo = { name: 'pgt', resourceType: '', userName: 'postgres', connectionId: '12345678' };
|
|
const registration: Registration = { instanceName: '', state: '', instanceType: ResourceType.postgresInstances };
|
|
postgresModel = new PostgresModel(controllerModel, postgresResource, registration, new AzureArcTreeDataProvider(TypeMoq.Mock.ofType<vscode.ExtensionContext>().object));
|
|
|
|
//Stub calling refresh postgres model
|
|
sinon.stub(azdataApi.arc.postgres.server, 'show').resolves(FakePostgresServerShowOutput);
|
|
|
|
//Stub how to get connection profile
|
|
const iconnectionProfileMock = TypeMoq.Mock.ofType<azdata.IConnectionProfile>();
|
|
iconnectionProfileMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(ConnectToPGSqlDialog.prototype, 'waitForClose').returns(Promise.resolve(iconnectionProfileMock.object));
|
|
const cancelButtonMock = TypeMoq.Mock.ofType<azdata.window.Button>();
|
|
cancelButtonMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const dialogMock = TypeMoq.Mock.ofType<azdata.window.Dialog>();
|
|
dialogMock.setup(x => x.cancelButton).returns(() => cancelButtonMock.object);
|
|
dialogMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.window, 'createModelViewDialog').returns(dialogMock.object);
|
|
sinon.stub(azdata.window, 'openDialog');
|
|
|
|
sinon.stub(azdata.connection, 'getUriForConnection');
|
|
|
|
//Call to provide external endpoint
|
|
await postgresModel.refresh();
|
|
});
|
|
|
|
it('Throw error when trying to connect fails', async function (): Promise<void> {
|
|
const errorMessage = 'Mock connection fail occured';
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => false);
|
|
connectionResultMock.setup(x => x.errorMessage).returns(() => errorMessage);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const connect = sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
await should(postgresModel.getEngineSettings()).be.rejectedWith(new Error(errorMessage));
|
|
sinon.assert.calledOnce(connect);
|
|
});
|
|
|
|
it('Update active connection id when connect passes', async function (): Promise<void> {
|
|
const connectionID = '098765';
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => true);
|
|
connectionResultMock.setup(x => x.connectionId).returns(() => connectionID);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
const connect = sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
const array: azdata.DbCellValue[][] = [];
|
|
|
|
const executeMock = TypeMoq.Mock.ofType<azdata.SimpleExecuteResult>();
|
|
executeMock.setup(x => x.rows).returns(() => array);
|
|
executeMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const providerMock = TypeMoq.Mock.ofType<azdata.QueryProvider>();
|
|
providerMock.setup(x => x.runQueryAndReturn(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => executeMock.object);
|
|
providerMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.dataprotocol, 'getProvider').returns(providerMock.object);
|
|
|
|
await postgresModel.getEngineSettings();
|
|
sinon.assert.calledOnce(connect);
|
|
sinon.assert.match(postgresModel['_activeConnectionId'], connectionID);
|
|
});
|
|
|
|
it('Updates engineSettingsLastUpdated after populating engine settings', async function (): Promise<void> {
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => true);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
const array: azdata.DbCellValue[][] = [];
|
|
|
|
const executeMock = TypeMoq.Mock.ofType<azdata.SimpleExecuteResult>();
|
|
executeMock.setup(x => x.rows).returns(() => array);
|
|
executeMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const providerMock = TypeMoq.Mock.ofType<azdata.QueryProvider>();
|
|
providerMock.setup(x => x.runQueryAndReturn(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => executeMock.object);
|
|
providerMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.dataprotocol, 'getProvider').returns(providerMock.object);
|
|
|
|
await postgresModel.getEngineSettings();
|
|
should(postgresModel.engineSettingsLastUpdated).be.Date();
|
|
});
|
|
|
|
it('Calls onEngineSettingsUpdated event after populating engine settings', async function (): Promise<void> {
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => true);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
const array: azdata.DbCellValue[][] = [];
|
|
|
|
const executeMock = TypeMoq.Mock.ofType<azdata.SimpleExecuteResult>();
|
|
executeMock.setup(x => x.rows).returns(() => array);
|
|
executeMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const providerMock = TypeMoq.Mock.ofType<azdata.QueryProvider>();
|
|
providerMock.setup(x => x.runQueryAndReturn(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => executeMock.object);
|
|
providerMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.dataprotocol, 'getProvider').returns(providerMock.object);
|
|
|
|
const onEngineSettingsUpdated = sinon.spy(vscode.EventEmitter.prototype, 'fire');
|
|
|
|
await postgresModel.getEngineSettings();
|
|
sinon.assert.calledOnceWithExactly(onEngineSettingsUpdated, postgresModel.workerNodesEngineSettings);
|
|
});
|
|
|
|
it('Populating engine settings skips certain parameters', async function (): Promise<void> {
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => true);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
const rows: azdata.DbCellValue[][] = [
|
|
[{
|
|
displayValue: 'archive_timeout',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
}]
|
|
];
|
|
|
|
const executeMock = TypeMoq.Mock.ofType<azdata.SimpleExecuteResult>();
|
|
executeMock.setup(x => x.rows).returns(() => rows);
|
|
executeMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const providerMock = TypeMoq.Mock.ofType<azdata.QueryProvider>();
|
|
providerMock.setup(x => x.runQueryAndReturn(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => executeMock.object);
|
|
providerMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.dataprotocol, 'getProvider').returns(providerMock.object);
|
|
|
|
await postgresModel.getEngineSettings();
|
|
should(postgresModel.workerNodesEngineSettings.pop()).be.undefined();
|
|
});
|
|
|
|
it('Populates engine settings accurately', async function (): Promise<void> {
|
|
const connectionResultMock = TypeMoq.Mock.ofType<azdata.ConnectionResult>();
|
|
connectionResultMock.setup(x => x.connected).returns(() => true);
|
|
connectionResultMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.connection, 'connect').returns(Promise.resolve(connectionResultMock.object));
|
|
|
|
const rows: azdata.DbCellValue[][] = [
|
|
[{
|
|
displayValue: 'test0',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
},
|
|
{
|
|
displayValue: 'test1',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
},
|
|
{
|
|
displayValue: 'test2',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
},
|
|
{
|
|
displayValue: 'test3',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
},
|
|
{
|
|
displayValue: 'test4',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
},
|
|
{
|
|
displayValue: 'test5',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
},
|
|
{
|
|
displayValue: 'test6',
|
|
isNull: false,
|
|
invariantCultureDisplayValue: ''
|
|
}],
|
|
];
|
|
|
|
const engineSettingsModelCompare: EngineSettingsModel = {
|
|
parameterName: 'test0',
|
|
value: 'test1',
|
|
description: 'test2',
|
|
min: 'test3',
|
|
max: 'test4',
|
|
options: 'test5',
|
|
type: 'test6'
|
|
};
|
|
|
|
const executeMock = TypeMoq.Mock.ofType<azdata.SimpleExecuteResult>();
|
|
executeMock.setup(x => x.rows).returns(() => rows);
|
|
executeMock.setup((x: any) => x.then).returns(() => undefined);
|
|
|
|
const providerMock = TypeMoq.Mock.ofType<azdata.QueryProvider>();
|
|
providerMock.setup(x => x.runQueryAndReturn(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(async () => executeMock.object);
|
|
providerMock.setup((x: any) => x.then).returns(() => undefined);
|
|
sinon.stub(azdata.dataprotocol, 'getProvider').returns(providerMock.object);
|
|
|
|
await postgresModel.getEngineSettings();
|
|
should(postgresModel.workerNodesEngineSettings.pop()).be.match(engineSettingsModelCompare);
|
|
});
|
|
|
|
});
|
|
|
|
});
|