mirror of
https://github.com/ckaczor/azuredatastudio.git
synced 2026-02-16 10:58:30 -05:00
Machine Learning Services extension with package management feature (#8622)
* Machine Learning Services extension with package management feature
This commit is contained in:
Leila Lali
48
extensions/machine-learning-services/src/test/index.ts
Normal file
48
extensions/machine-learning-services/src/test/index.ts
Normal file
@@ -0,0 +1,48 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
const path = require('path');
|
||||
const testRunner = require('vscode/lib/testrunner');
|
||||
|
||||
const suite = 'machine learning Extension Tests';
|
||||
|
||||
const options: any = {
|
||||
ui: 'bdd',
|
||||
useColors: true,
|
||||
timeout: 600000
|
||||
};
|
||||
|
||||
// set relevant mocha options from the environment
|
||||
if (process.env.ADS_TEST_GREP) {
|
||||
options.grep = process.env.ADS_TEST_GREP;
|
||||
console.log(`setting options.grep to: ${options.grep}`);
|
||||
}
|
||||
if (process.env.ADS_TEST_INVERT_GREP) {
|
||||
options.invert = parseInt(process.env.ADS_TEST_INVERT_GREP);
|
||||
console.log(`setting options.invert to: ${options.invert}`);
|
||||
}
|
||||
if (process.env.ADS_TEST_TIMEOUT) {
|
||||
options.timeout = parseInt(process.env.ADS_TEST_TIMEOUT);
|
||||
console.log(`setting options.timeout to: ${options.timeout}`);
|
||||
}
|
||||
if (process.env.ADS_TEST_RETRIES) {
|
||||
options.retries = parseInt(process.env.ADS_TEST_RETRIES);
|
||||
console.log(`setting options.retries to: ${options.retries}`);
|
||||
}
|
||||
|
||||
if (process.env.BUILD_ARTIFACTSTAGINGDIRECTORY) {
|
||||
options.reporter = 'mocha-multi-reporters';
|
||||
options.reporterOptions = {
|
||||
reporterEnabled: 'spec, mocha-junit-reporter',
|
||||
mochaJunitReporterReporterOptions: {
|
||||
testsuitesTitle: `${suite} ${process.platform}`,
|
||||
mochaFile: path.join(process.env.BUILD_ARTIFACTSTAGINGDIRECTORY, `test-results/${process.platform}-${suite.toLowerCase().replace(/[^\w]/g, '-')}-results.xml`)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
testRunner.configure(options);
|
||||
|
||||
export = testRunner;
|
||||
@@ -0,0 +1,117 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import * as vscode from 'vscode';
|
||||
import * as should from 'should';
|
||||
import 'mocha';
|
||||
import * as TypeMoq from 'typemoq';
|
||||
import * as path from 'path';
|
||||
import { ApiWrapper } from '../common/apiWrapper';
|
||||
import { QueryRunner } from '../common/queryRunner';
|
||||
import { ProcessService } from '../common/processService';
|
||||
import MainController from '../controllers/mainController';
|
||||
import { PackageManager } from '../packageManagement/packageManager';
|
||||
|
||||
interface TestContext {
|
||||
|
||||
apiWrapper: TypeMoq.IMock<ApiWrapper>;
|
||||
queryRunner: TypeMoq.IMock<QueryRunner>;
|
||||
processService: TypeMoq.IMock<ProcessService>;
|
||||
context: vscode.ExtensionContext;
|
||||
outputChannel: vscode.OutputChannel;
|
||||
extension: vscode.Extension<any>;
|
||||
packageManager: TypeMoq.IMock<PackageManager>;
|
||||
}
|
||||
|
||||
function createContext(): TestContext {
|
||||
let extensionPath = path.join(__dirname, '..', '..');
|
||||
return {
|
||||
apiWrapper: TypeMoq.Mock.ofType(ApiWrapper),
|
||||
queryRunner: TypeMoq.Mock.ofType(QueryRunner),
|
||||
processService: TypeMoq.Mock.ofType(ProcessService),
|
||||
packageManager: TypeMoq.Mock.ofType(PackageManager),
|
||||
context: {
|
||||
subscriptions: [],
|
||||
workspaceState: {
|
||||
get: () => {return undefined;},
|
||||
update: () => {return Promise.resolve();}
|
||||
},
|
||||
globalState: {
|
||||
get: () => {return Promise.resolve();},
|
||||
update: () => {return Promise.resolve();}
|
||||
},
|
||||
extensionPath: extensionPath,
|
||||
asAbsolutePath: () => {return '';},
|
||||
storagePath: '',
|
||||
globalStoragePath: '',
|
||||
logPath: ''
|
||||
},
|
||||
outputChannel: {
|
||||
name: '',
|
||||
append: () => { },
|
||||
appendLine: () => { },
|
||||
clear: () => { },
|
||||
show: () => { },
|
||||
hide: () => { },
|
||||
dispose: () => { }
|
||||
},
|
||||
extension: {
|
||||
id: '',
|
||||
extensionPath: '',
|
||||
isActive: true,
|
||||
packageJSON: {},
|
||||
extensionKind: vscode.ExtensionKind.UI,
|
||||
exports: {},
|
||||
activate: () => { return Promise.resolve(); }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function createController(testContext: TestContext): MainController {
|
||||
let controller = new MainController(testContext.context, testContext.apiWrapper.object, testContext.queryRunner.object, testContext.processService.object);
|
||||
controller.packageManager = testContext.packageManager.object;
|
||||
return controller;
|
||||
}
|
||||
|
||||
describe('Main Controller', () => {
|
||||
it('Should create new instance successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
testContext.apiWrapper.setup(x => x.createOutputChannel(TypeMoq.It.isAny())).returns(() => testContext.outputChannel);
|
||||
should.doesNotThrow(() => createController(testContext));
|
||||
});
|
||||
|
||||
it('initialize Should install dependencies successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
testContext.apiWrapper.setup(x => x.createOutputChannel(TypeMoq.It.isAny())).returns(() => testContext.outputChannel);
|
||||
testContext.apiWrapper.setup(x => x.getExtension(TypeMoq.It.isAny())).returns(() => testContext.extension);
|
||||
testContext.packageManager.setup(x => x.managePackages()).returns(() => Promise.resolve());
|
||||
testContext.packageManager.setup(x => x.installDependencies()).returns(() => Promise.resolve());
|
||||
testContext.apiWrapper.setup(x => x.registerCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny()));
|
||||
let controller = createController(testContext);
|
||||
await controller.activate();
|
||||
should.deepEqual(controller.config.requiredPythonPackages, [
|
||||
{ name: 'pymssql', version: '2.1.4' },
|
||||
{ name: 'sqlmlutils', version: '' }
|
||||
]);
|
||||
});
|
||||
|
||||
it('initialize Should show and error in output channel if installing dependencies fails', async function (): Promise<void> {
|
||||
let errorReported = false;
|
||||
let testContext = createContext();
|
||||
testContext.apiWrapper.setup(x => x.createOutputChannel(TypeMoq.It.isAny())).returns(() => testContext.outputChannel);
|
||||
testContext.apiWrapper.setup(x => x.getExtension(TypeMoq.It.isAny())).returns(() => testContext.extension);
|
||||
testContext.packageManager.setup(x => x.managePackages()).returns(() => Promise.resolve());
|
||||
testContext.packageManager.setup(x => x.installDependencies()).returns(() => Promise.reject());
|
||||
testContext.apiWrapper.setup(x => x.registerCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny()));
|
||||
testContext.outputChannel.appendLine = () => {
|
||||
errorReported = true;
|
||||
};
|
||||
let controller = createController(testContext);
|
||||
await controller.activate();
|
||||
should.equal(errorReported, true);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,223 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import * as azdata from 'azdata';
|
||||
|
||||
import * as should from 'should';
|
||||
import 'mocha';
|
||||
import * as TypeMoq from 'typemoq';
|
||||
import { PackageManager } from '../../packageManagement/packageManager';
|
||||
import { SqlPythonPackageManageProvider } from '../../packageManagement/sqlPackageManageProvider';
|
||||
import { createContext, TestContext } from './utils';
|
||||
|
||||
describe('Package Manager', () => {
|
||||
it('Should initialize SQL package manager successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
should.doesNotThrow(() => createPackageManager(testContext));
|
||||
should.equal(testContext.nbExtensionApis.getPackageManagers().has(SqlPythonPackageManageProvider.ProviderId), true);
|
||||
});
|
||||
|
||||
it('Manage Package command Should execute the command for valid connection', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => {return Promise.resolve(connection);});
|
||||
testContext.apiWrapper.setup(x => x.executeCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {return Promise.resolve();});
|
||||
testContext.queryRunner.setup(x => x.isPythonInstalled(connection)).returns(() => {return Promise.resolve(true);});
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await packageManager.managePackages();
|
||||
testContext.apiWrapper.verify(x => x.executeCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
|
||||
});
|
||||
|
||||
it('Manage Package command Should show an error for connection without python installed', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => {return Promise.resolve(connection);});
|
||||
testContext.apiWrapper.setup(x => x.executeCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {return Promise.resolve();});
|
||||
testContext.apiWrapper.setup(x => x.showInfoMessage(TypeMoq.It.isAny()));
|
||||
testContext.queryRunner.setup(x => x.isPythonInstalled(connection)).returns(() => {return Promise.resolve(false);});
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await packageManager.managePackages();
|
||||
testContext.apiWrapper.verify(x => x.showInfoMessage(TypeMoq.It.isAny()), TypeMoq.Times.once());
|
||||
});
|
||||
|
||||
it('Manage Package command Should show an error for no connection', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let connection: azdata.connection.ConnectionProfile;
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => {return Promise.resolve(connection);});
|
||||
testContext.apiWrapper.setup(x => x.executeCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {return Promise.resolve();});
|
||||
testContext.apiWrapper.setup(x => x.showInfoMessage(TypeMoq.It.isAny()));
|
||||
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await packageManager.managePackages();
|
||||
testContext.apiWrapper.verify(x => x.showInfoMessage(TypeMoq.It.isAny()), TypeMoq.Times.once());
|
||||
});
|
||||
|
||||
it('installDependencies Should install python if does not exist', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let pythonInstalled = false;
|
||||
let installedPackages = `[
|
||||
{"name":"pymssql","version":"2.1.4"},
|
||||
{"name":"sqlmlutils","version":"1.1.1"}
|
||||
]`;
|
||||
testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
|
||||
operationInfo.operation(testContext.op);
|
||||
});
|
||||
testContext.jupyterInstallation.installPythonPackage = () => {
|
||||
pythonInstalled = true;
|
||||
return Promise.resolve();
|
||||
};
|
||||
testContext.processService.setup(x => x.executeBufferedCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {return Promise.resolve(installedPackages);});
|
||||
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await packageManager.installDependencies();
|
||||
should.equal(testContext.getOpStatus(), azdata.TaskStatus.Succeeded);
|
||||
should.equal(pythonInstalled, true);
|
||||
});
|
||||
|
||||
it('installDependencies Should fail the task if installing python fails', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let installedPackages = `[
|
||||
{"name":"pymssql","version":"2.1.4"},
|
||||
{"name":"sqlmlutils","version":"1.1.1"}
|
||||
]`;
|
||||
testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
|
||||
operationInfo.operation(testContext.op);
|
||||
});
|
||||
testContext.jupyterInstallation.installPythonPackage = () => {
|
||||
return Promise.reject();
|
||||
};
|
||||
testContext.processService.setup(x => x.executeBufferedCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {return Promise.resolve(installedPackages);});
|
||||
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await should(packageManager.installDependencies()).rejected();
|
||||
should.equal(testContext.getOpStatus(), azdata.TaskStatus.Failed);
|
||||
});
|
||||
|
||||
it('installDependencies Should not install packages if already installed', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesInstalled = false;
|
||||
let installedPackages = `[
|
||||
{"name":"pymssql","version":"2.1.4"},
|
||||
{"name":"sqlmlutils","version":"1.1.1"}
|
||||
]`;
|
||||
testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
|
||||
operationInfo.operation(testContext.op);
|
||||
});
|
||||
testContext.jupyterInstallation.installPythonPackage = () => {
|
||||
return Promise.resolve();
|
||||
};
|
||||
testContext.processService.setup(x => x.executeBufferedCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((command) => {
|
||||
if (command.indexOf('pip install') > 0) {
|
||||
packagesInstalled = true;
|
||||
}
|
||||
return Promise.resolve(installedPackages);
|
||||
});
|
||||
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await packageManager.installDependencies();
|
||||
should.equal(testContext.getOpStatus(), azdata.TaskStatus.Succeeded);
|
||||
should.equal(packagesInstalled, false);
|
||||
});
|
||||
|
||||
it('installDependencies Should install packages that are not already installed', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesInstalled = false;
|
||||
let installedPackages = `[
|
||||
{"name":"pymssql","version":"2.1.4"}
|
||||
]`;
|
||||
testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
|
||||
operationInfo.operation(testContext.op);
|
||||
});
|
||||
testContext.jupyterInstallation.installPythonPackage = () => {
|
||||
return Promise.resolve();
|
||||
};
|
||||
testContext.processService.setup(x => x.executeBufferedCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((command) => {
|
||||
if (command.indexOf('pip install') > 0) {
|
||||
packagesInstalled = true;
|
||||
}
|
||||
return Promise.resolve(installedPackages);
|
||||
});
|
||||
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await packageManager.installDependencies();
|
||||
should.equal(testContext.getOpStatus(), azdata.TaskStatus.Succeeded);
|
||||
should.equal(packagesInstalled, true);
|
||||
});
|
||||
|
||||
it('installDependencies Should install packages if list packages fails', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesInstalled = false;
|
||||
testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
|
||||
operationInfo.operation(testContext.op);
|
||||
});
|
||||
testContext.jupyterInstallation.installPythonPackage = () => {
|
||||
return Promise.resolve();
|
||||
};
|
||||
testContext.processService.setup(x => x.executeBufferedCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((command,) => {
|
||||
if (command.indexOf('pip list') > 0) {
|
||||
return Promise.reject();
|
||||
} else if (command.indexOf('pip install') > 0) {
|
||||
packagesInstalled = true;
|
||||
return Promise.resolve('');
|
||||
} else {
|
||||
return Promise.resolve('');
|
||||
}
|
||||
});
|
||||
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await packageManager.installDependencies();
|
||||
should.equal(testContext.getOpStatus(), azdata.TaskStatus.Succeeded);
|
||||
should.equal(packagesInstalled, true);
|
||||
});
|
||||
|
||||
it('installDependencies Should fail if install packages fails', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesInstalled = false;
|
||||
let installedPackages = `[
|
||||
{"name":"pymssql","version":"2.1.4"}
|
||||
]`;
|
||||
testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
|
||||
operationInfo.operation(testContext.op);
|
||||
});
|
||||
testContext.jupyterInstallation.installPythonPackage = () => {
|
||||
return Promise.resolve();
|
||||
};
|
||||
testContext.processService.setup(x => x.executeBufferedCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((command) => {
|
||||
if (command.indexOf('pip list') > 0) {
|
||||
return Promise.resolve(installedPackages);
|
||||
} else if (command.indexOf('pip install') > 0) {
|
||||
return Promise.reject();
|
||||
} else {
|
||||
return Promise.resolve('');
|
||||
}
|
||||
});
|
||||
|
||||
let packageManager = createPackageManager(testContext);
|
||||
await should(packageManager.installDependencies()).rejected();
|
||||
should.equal(testContext.getOpStatus(), azdata.TaskStatus.Failed);
|
||||
should.equal(packagesInstalled, false);
|
||||
});
|
||||
|
||||
function createPackageManager(testContext: TestContext): PackageManager {
|
||||
testContext.config.setup(x => x.requiredPythonPackages).returns( () => [
|
||||
{ name: 'pymssql', version: '2.1.4' },
|
||||
{ name: 'sqlmlutils', version: '' }
|
||||
]);
|
||||
let packageManager = new PackageManager(
|
||||
testContext.nbExtensionApis,
|
||||
testContext.outputChannel,
|
||||
'',
|
||||
testContext.apiWrapper.object,
|
||||
testContext.queryRunner.object,
|
||||
testContext.processService.object,
|
||||
testContext.config.object);
|
||||
packageManager.init();
|
||||
return packageManager;
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
@@ -0,0 +1,373 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import * as azdata from 'azdata';
|
||||
import * as should from 'should';
|
||||
import 'mocha';
|
||||
import * as TypeMoq from 'typemoq';
|
||||
import * as constants from '../../common/constants';
|
||||
import { SqlPythonPackageManageProvider } from '../../packageManagement/sqlPackageManageProvider';
|
||||
import { createContext, TestContext } from './utils';
|
||||
import * as nbExtensionApis from '../../typings/notebookServices';
|
||||
|
||||
describe('SQL Package Manager', () => {
|
||||
it('Should create SQL package manager successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
should.doesNotThrow(() => createProvider(testContext));
|
||||
});
|
||||
|
||||
it('Should return provider Id and target correctly', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let provider = createProvider(testContext);
|
||||
should.deepEqual(SqlPythonPackageManageProvider.ProviderId, provider.providerId);
|
||||
should.deepEqual({ location: 'SQL', packageType: 'Python' }, provider.packageTarget);
|
||||
});
|
||||
|
||||
it('listPackages Should return packages sorted by name', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packages: nbExtensionApis.IPackageDetails[] = [
|
||||
{
|
||||
'name': 'b-name',
|
||||
'version': '1.1.1'
|
||||
},
|
||||
{
|
||||
'name': 'a-name',
|
||||
'version': '1.1.2'
|
||||
}
|
||||
];
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.queryRunner.setup(x => x.getPythonPackages(TypeMoq.It.isAny())).returns(() => Promise.resolve(packages));
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.listPackages();
|
||||
let expected = [
|
||||
{
|
||||
'name': 'a-name',
|
||||
'version': '1.1.2'
|
||||
},
|
||||
{
|
||||
'name': 'b-name',
|
||||
'version': '1.1.1'
|
||||
}
|
||||
];
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('listPackages Should return empty packages if undefined packages returned', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let packages: nbExtensionApis.IPackageDetails[];
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.queryRunner.setup(x => x.getPythonPackages(TypeMoq.It.isAny())).returns(() => Promise.resolve(packages));
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.listPackages();
|
||||
let expected: nbExtensionApis.IPackageDetails[] = [];
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('listPackages Should return empty packages if empty packages returned', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.queryRunner.setup(x => x.getPythonPackages(TypeMoq.It.isAny())).returns(() => Promise.resolve([]));
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.listPackages();
|
||||
let expected: nbExtensionApis.IPackageDetails[] = [];
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('installPackages Should install given packages successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesUpdated = false;
|
||||
let packages: nbExtensionApis.IPackageDetails[] = [
|
||||
{
|
||||
'name': 'a-name',
|
||||
'version': '1.1.2'
|
||||
},
|
||||
{
|
||||
'name': 'b-name',
|
||||
'version': '1.1.1'
|
||||
}
|
||||
];
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
connection.serverName = 'serverName';
|
||||
connection.databaseName = 'databaseName';
|
||||
let credentials = { [azdata.ConnectionOptionSpecialType.password]: 'password' };
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.apiWrapper.setup(x => x.getCredentials(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(credentials); });
|
||||
testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((path, scripts: string[]) => {
|
||||
|
||||
if (path && scripts.find(x => x.indexOf('install') > 0) &&
|
||||
scripts.find(x => x.indexOf('port=1433') > 0) &&
|
||||
scripts.find(x => x.indexOf('server="serverName"') > 0) &&
|
||||
scripts.find(x => x.indexOf('database="databaseName"') > 0) &&
|
||||
scripts.find(x => x.indexOf('package="a-name"') > 0) &&
|
||||
scripts.find(x => x.indexOf('version="1.1.2"') > 0) &&
|
||||
scripts.find(x => x.indexOf('pwd="password"') > 0)) {
|
||||
packagesUpdated = true;
|
||||
}
|
||||
|
||||
return Promise.resolve();
|
||||
});
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
await provider.installPackages(packages, false);
|
||||
|
||||
should.deepEqual(packagesUpdated, true);
|
||||
});
|
||||
|
||||
it('uninstallPackages Should uninstall given packages successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesUpdated = false;
|
||||
let packages: nbExtensionApis.IPackageDetails[] = [
|
||||
{
|
||||
'name': 'a-name',
|
||||
'version': '1.1.2'
|
||||
},
|
||||
{
|
||||
'name': 'b-name',
|
||||
'version': '1.1.1'
|
||||
}
|
||||
];
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
connection.serverName = 'serverName';
|
||||
connection.databaseName = 'databaseName';
|
||||
let credentials = { [azdata.ConnectionOptionSpecialType.password]: 'password' };
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.apiWrapper.setup(x => x.getCredentials(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(credentials); });
|
||||
testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((path, scripts: string[]) => {
|
||||
|
||||
if (path && scripts.find(x => x.indexOf('uninstall') > 0) &&
|
||||
scripts.find(x => x.indexOf('port=1433') > 0) &&
|
||||
scripts.find(x => x.indexOf('server="serverName"') > 0) &&
|
||||
scripts.find(x => x.indexOf('database="databaseName"') > 0) &&
|
||||
scripts.find(x => x.indexOf('package_name="a-name"') > 0) &&
|
||||
scripts.find(x => x.indexOf('pwd="password"') > 0)) {
|
||||
packagesUpdated = true;
|
||||
}
|
||||
|
||||
return Promise.resolve();
|
||||
});
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
await provider.uninstallPackages(packages);
|
||||
|
||||
should.deepEqual(packagesUpdated, true);
|
||||
});
|
||||
|
||||
it('installPackages Should include port name in the script', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesUpdated = false;
|
||||
let packages: nbExtensionApis.IPackageDetails[] = [
|
||||
{
|
||||
'name': 'a-name',
|
||||
'version': '1.1.2'
|
||||
},
|
||||
{
|
||||
'name': 'b-name',
|
||||
'version': '1.1.1'
|
||||
}
|
||||
];
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
connection.serverName = 'serverName,3433';
|
||||
connection.databaseName = 'databaseName';
|
||||
let credentials = { [azdata.ConnectionOptionSpecialType.password]: 'password' };
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.apiWrapper.setup(x => x.getCredentials(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(credentials); });
|
||||
testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((path, scripts: string[]) => {
|
||||
|
||||
if (path && scripts.find(x => x.indexOf('install') > 0) &&
|
||||
scripts.find(x => x.indexOf('port=3433') > 0) &&
|
||||
scripts.find(x => x.indexOf('server="serverName"') > 0) &&
|
||||
scripts.find(x => x.indexOf('database="databaseName"') > 0) &&
|
||||
scripts.find(x => x.indexOf('package="a-name"') > 0) &&
|
||||
scripts.find(x => x.indexOf('version="1.1.2"') > 0) &&
|
||||
scripts.find(x => x.indexOf('pwd="password"') > 0)) {
|
||||
packagesUpdated = true;
|
||||
}
|
||||
|
||||
return Promise.resolve();
|
||||
});
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
await provider.installPackages(packages, false);
|
||||
|
||||
should.deepEqual(packagesUpdated, true);
|
||||
});
|
||||
|
||||
it('installPackages Should not install any packages give empty list', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesUpdated = false;
|
||||
let packages: nbExtensionApis.IPackageDetails[] = [
|
||||
];
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let credentials = { ['azdata.ConnectionOptionSpecialType.password']: 'password' };
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.apiWrapper.setup(x => x.getCredentials(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(credentials); });
|
||||
testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {
|
||||
packagesUpdated = true;
|
||||
return Promise.resolve();
|
||||
});
|
||||
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
await provider.installPackages(packages, false);
|
||||
|
||||
should.deepEqual(packagesUpdated, false);
|
||||
});
|
||||
|
||||
it('uninstallPackages Should not uninstall any packages give empty list', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagesUpdated = false;
|
||||
let packages: nbExtensionApis.IPackageDetails[] = [
|
||||
];
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let credentials = { ['azdata.ConnectionOptionSpecialType.password']: 'password' };
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.apiWrapper.setup(x => x.getCredentials(TypeMoq.It.isAny())).returns(() => { return Promise.resolve(credentials); });
|
||||
testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {
|
||||
packagesUpdated = true;
|
||||
return Promise.resolve();
|
||||
});
|
||||
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
await provider.uninstallPackages(packages);
|
||||
|
||||
should.deepEqual(packagesUpdated, false);
|
||||
});
|
||||
|
||||
it('canUseProvider Should return false for no connection', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let connection: azdata.connection.ConnectionProfile;
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.canUseProvider();
|
||||
|
||||
should.deepEqual(actual, false);
|
||||
});
|
||||
|
||||
it('canUseProvider Should return false if connection does not have python installed', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.queryRunner.setup(x => x.isPythonInstalled(TypeMoq.It.isAny())).returns(() => Promise.resolve(false));
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.canUseProvider();
|
||||
|
||||
should.deepEqual(actual, false);
|
||||
});
|
||||
|
||||
it('canUseProvider Should return true if connection has python installed', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
testContext.queryRunner.setup(x => x.isPythonInstalled(TypeMoq.It.isAny())).returns(() => Promise.resolve(true));
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.canUseProvider();
|
||||
|
||||
should.deepEqual(actual, true);
|
||||
});
|
||||
|
||||
it('getPackageOverview Should not return undefined if python package provider not found', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.getPackageOverview('package name');
|
||||
|
||||
should.notEqual(actual, undefined);
|
||||
});
|
||||
|
||||
it('getPackageOverview Should return package info using python packages provider', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let packagePreview = {
|
||||
'name': 'a-name',
|
||||
'versions': ['1.1.2'],
|
||||
'summary': ''
|
||||
};
|
||||
let pythonPackageManager: nbExtensionApis.IPackageManageProvider = {
|
||||
providerId: 'localhost_Pip',
|
||||
packageTarget: { location: '', packageType: '' },
|
||||
listPackages: () => { return Promise.resolve([]); },
|
||||
installPackages: () => { return Promise.resolve(); },
|
||||
uninstallPackages: () => { return Promise.resolve(); },
|
||||
canUseProvider: () => { return Promise.resolve(true); },
|
||||
getLocationTitle: () => { return Promise.resolve(''); },
|
||||
getPackageOverview: () => { return Promise.resolve(packagePreview); }
|
||||
};
|
||||
testContext.nbExtensionApis.registerPackageManager(pythonPackageManager.providerId, pythonPackageManager);
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.getPackageOverview('package name');
|
||||
|
||||
should.deepEqual(actual, packagePreview);
|
||||
});
|
||||
|
||||
it('getLocationTitle Should default string for no connection', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let connection: azdata.connection.ConnectionProfile;
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.getLocationTitle();
|
||||
|
||||
should.deepEqual(actual, constants.packageManagerNoConnection);
|
||||
});
|
||||
|
||||
it('getLocationTitle Should return connection title string for valid connection', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
connection.serverName = 'serverName';
|
||||
connection.databaseName = 'databaseName';
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.getLocationTitle();
|
||||
|
||||
should.deepEqual(actual, `${connection.serverName} ${connection.databaseName}`);
|
||||
});
|
||||
|
||||
it('getLocationTitle Should return server name as connection title if there is not database name', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
connection.serverName = 'serverName';
|
||||
testContext.apiWrapper.setup(x => x.getCurrentConnection()).returns(() => { return Promise.resolve(connection); });
|
||||
|
||||
let provider = createProvider(testContext);
|
||||
let actual = await provider.getLocationTitle();
|
||||
|
||||
should.deepEqual(actual, `${connection.serverName} `);
|
||||
});
|
||||
|
||||
function createProvider(testContext: TestContext): SqlPythonPackageManageProvider {
|
||||
return new SqlPythonPackageManageProvider(
|
||||
testContext.nbExtensionApis,
|
||||
testContext.outputChannel,
|
||||
'',
|
||||
testContext.apiWrapper.object,
|
||||
testContext.queryRunner.object,
|
||||
testContext.processService.object);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,83 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import * as vscode from 'vscode';
|
||||
import * as azdata from 'azdata';
|
||||
import * as nbExtensionApis from '../../typings/notebookServices';
|
||||
import * as TypeMoq from 'typemoq';
|
||||
import { ApiWrapper } from '../../common/apiWrapper';
|
||||
import { QueryRunner } from '../../common/queryRunner';
|
||||
import { ProcessService } from '../../common/processService';
|
||||
import { Config } from '../../common/config';
|
||||
|
||||
export interface TestContext {
|
||||
jupyterInstallation: nbExtensionApis.IJupyterServerInstallation;
|
||||
jupyterController: nbExtensionApis.IJupyterController;
|
||||
nbExtensionApis: nbExtensionApis.IExtensionApi;
|
||||
outputChannel: vscode.OutputChannel;
|
||||
processService: TypeMoq.IMock<ProcessService>;
|
||||
apiWrapper: TypeMoq.IMock<ApiWrapper>;
|
||||
queryRunner: TypeMoq.IMock<QueryRunner>;
|
||||
config: TypeMoq.IMock<Config>;
|
||||
op: azdata.BackgroundOperation;
|
||||
getOpStatus: () => azdata.TaskStatus;
|
||||
}
|
||||
|
||||
export function createContext(): TestContext {
|
||||
let opStatus: azdata.TaskStatus;
|
||||
let packages = new Map<string, nbExtensionApis.IPackageManageProvider>();
|
||||
let jupyterInstallation: nbExtensionApis.IJupyterServerInstallation = {
|
||||
installCondaPackages: () => { return Promise.resolve(); },
|
||||
getInstalledPipPackages: () => { return Promise.resolve([]); },
|
||||
installPipPackages: () => { return Promise.resolve(); },
|
||||
uninstallPipPackages: () => { return Promise.resolve(); },
|
||||
uninstallCondaPackages: () => { return Promise.resolve(); },
|
||||
executeBufferedCommand: () => { return Promise.resolve(''); },
|
||||
executeStreamedCommand: () => { return Promise.resolve(); },
|
||||
pythonExecutable: '',
|
||||
pythonInstallationPath: '',
|
||||
installPythonPackage: () => { return Promise.resolve(); }
|
||||
};
|
||||
|
||||
let jupyterController = {
|
||||
jupyterInstallation: jupyterInstallation
|
||||
};
|
||||
|
||||
return {
|
||||
|
||||
jupyterInstallation: jupyterInstallation,
|
||||
jupyterController: jupyterController,
|
||||
nbExtensionApis: {
|
||||
getJupyterController: () => { return jupyterController; },
|
||||
registerPackageManager: (providerId: string, packageManagerProvider: nbExtensionApis.IPackageManageProvider) => {
|
||||
packages.set(providerId, packageManagerProvider);
|
||||
},
|
||||
getPackageManagers: () => { return packages; },
|
||||
},
|
||||
outputChannel: {
|
||||
name: '',
|
||||
append: () => { },
|
||||
appendLine: () => { },
|
||||
clear: () => { },
|
||||
show: () => { },
|
||||
hide: () => { },
|
||||
dispose: () => { }
|
||||
},
|
||||
processService: TypeMoq.Mock.ofType(ProcessService),
|
||||
apiWrapper: TypeMoq.Mock.ofType(ApiWrapper),
|
||||
queryRunner: TypeMoq.Mock.ofType(QueryRunner),
|
||||
config: TypeMoq.Mock.ofType(Config),
|
||||
op: {
|
||||
updateStatus: (status: azdata.TaskStatus) => {
|
||||
opStatus = status;
|
||||
},
|
||||
id: '',
|
||||
onCanceled: new vscode.EventEmitter<void>().event,
|
||||
},
|
||||
getOpStatus: () => { return opStatus; }
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,305 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import * as azdata from 'azdata';
|
||||
import { ApiWrapper } from '../common/apiWrapper';
|
||||
import * as TypeMoq from 'typemoq';
|
||||
import * as should from 'should';
|
||||
import { QueryRunner } from '../common/queryRunner';
|
||||
import { IPackageDetails } from '../typings/notebookServices';
|
||||
|
||||
interface TestContext {
|
||||
|
||||
apiWrapper: TypeMoq.IMock<ApiWrapper>;
|
||||
queryProvider: azdata.QueryProvider;
|
||||
}
|
||||
|
||||
function createContext(): TestContext {
|
||||
return {
|
||||
apiWrapper: TypeMoq.Mock.ofType(ApiWrapper),
|
||||
queryProvider: {
|
||||
providerId: '',
|
||||
cancelQuery: () => {return Promise.reject();},
|
||||
runQuery: () => {return Promise.reject();},
|
||||
runQueryStatement: () => {return Promise.reject();},
|
||||
runQueryString: () => {return Promise.reject();},
|
||||
runQueryAndReturn: () => { return Promise.reject(); },
|
||||
parseSyntax: () => {return Promise.reject();},
|
||||
getQueryRows: () => {return Promise.reject();},
|
||||
disposeQuery: () => {return Promise.reject();},
|
||||
saveResults: () => {return Promise.reject();},
|
||||
setQueryExecutionOptions: () => {return Promise.reject();},
|
||||
registerOnQueryComplete: () => {return Promise.reject();},
|
||||
registerOnBatchStart: () => {return Promise.reject();},
|
||||
registerOnBatchComplete: () => {return Promise.reject();},
|
||||
registerOnResultSetAvailable: () => {return Promise.reject();},
|
||||
registerOnResultSetUpdated: () => {return Promise.reject();},
|
||||
registerOnMessage: () => {return Promise.reject();},
|
||||
commitEdit: () => {return Promise.reject();},
|
||||
createRow: () => {return Promise.reject();},
|
||||
deleteRow: () => {return Promise.reject();},
|
||||
disposeEdit: () => {return Promise.reject();},
|
||||
initializeEdit: () => {return Promise.reject();},
|
||||
revertCell: () => {return Promise.reject();},
|
||||
revertRow: () => {return Promise.reject();},
|
||||
updateCell: () => {return Promise.reject();},
|
||||
getEditRows: () => {return Promise.reject();},
|
||||
registerOnEditSessionReady: () => {return Promise.reject();},
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
describe('Query Runner', () => {
|
||||
it('getPythonPackages Should return empty list if not provider found', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
let queryProvider: azdata.QueryProvider;
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => queryProvider);
|
||||
|
||||
let actual = await queryRunner.getPythonPackages(connection);
|
||||
should.deepEqual(actual, []);
|
||||
});
|
||||
|
||||
it('getPythonPackages Should return empty list if not provider throws', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.reject(); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.getPythonPackages(connection);
|
||||
should.deepEqual(actual, []);
|
||||
});
|
||||
|
||||
it('getPythonPackages Should return list if provider runs the query successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [
|
||||
[{
|
||||
displayValue: 'p1',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}, {
|
||||
displayValue: '1.1.1',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}],
|
||||
[{
|
||||
displayValue: 'p2',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}, {
|
||||
displayValue: '1.1.2',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}]
|
||||
];
|
||||
let expected = [
|
||||
{
|
||||
'name': 'p1',
|
||||
'version': '1.1.1'
|
||||
},
|
||||
{
|
||||
'name': 'p2',
|
||||
'version': '1.1.2'
|
||||
}
|
||||
];
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.getPythonPackages(connection);
|
||||
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('getPythonPackages Should return empty list if provider return no rows', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [
|
||||
];
|
||||
let expected: IPackageDetails[] = [];
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.getPythonPackages(connection);
|
||||
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('updateExternalScriptConfig Should update config successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [
|
||||
];
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
await should(queryRunner.updateExternalScriptConfig(connection, true)).resolved();
|
||||
|
||||
});
|
||||
|
||||
it('isPythonInstalled Should return true is provider returns valid result', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [
|
||||
[{
|
||||
displayValue: '1',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}]
|
||||
];
|
||||
let expected = true;
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.isPythonInstalled(connection);
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('isPythonInstalled Should return true is provider returns 0 as result', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [
|
||||
[{
|
||||
displayValue: '0',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}]
|
||||
];
|
||||
let expected = false;
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.isPythonInstalled(connection);
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('isPythonInstalled Should return false is provider returns no result', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [];
|
||||
let expected = false;
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.isPythonInstalled(connection);
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('isMachineLearningServiceEnabled Should return true is provider returns valid result', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [
|
||||
[{
|
||||
displayValue: '1',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}]
|
||||
];
|
||||
let expected = true;
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.isMachineLearningServiceEnabled(connection);
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('isMachineLearningServiceEnabled Should return true is provider returns 0 as result', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [
|
||||
[{
|
||||
displayValue: '0',
|
||||
isNull: false,
|
||||
invariantCultureDisplayValue: ''
|
||||
}]
|
||||
];
|
||||
let expected = false;
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.isMachineLearningServiceEnabled(connection);
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
it('isMachineLearningServiceEnabled Should return false is provider returns no result', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let rows: azdata.DbCellValue[][] = [];
|
||||
let expected = false;
|
||||
|
||||
let result : azdata.SimpleExecuteResult = {
|
||||
rowCount: 2,
|
||||
columnInfo: [],
|
||||
rows: rows,
|
||||
};
|
||||
let connection = new azdata.connection.ConnectionProfile();
|
||||
let queryRunner = new QueryRunner(testContext.apiWrapper.object);
|
||||
testContext.queryProvider.runQueryAndReturn = () => { return Promise.resolve(result); };
|
||||
testContext.apiWrapper.setup(x => x.getProvider<azdata.QueryProvider>(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => testContext.queryProvider);
|
||||
|
||||
let actual = await queryRunner.isMachineLearningServiceEnabled(connection);
|
||||
should.deepEqual(actual, expected);
|
||||
});
|
||||
|
||||
});
|
||||
Reference in New Issue
Block a user