mirror of
https://github.com/ckaczor/azuredatastudio.git
synced 2026-01-20 09:35:38 -05:00
303 lines
11 KiB
TypeScript
303 lines
11 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 * as vscode from 'vscode';
|
|
import * as should from 'should';
|
|
import * as sinon from 'sinon';
|
|
import * as TypeMoq from 'typemoq';
|
|
import * as uuid from 'uuid';
|
|
import * as fs from 'fs-extra';
|
|
import * as request from 'request';
|
|
import * as utils from '../../common/utils';
|
|
import { JupyterServerInstallation, PythonInstallSettings, PythonPkgDetails } from '../../jupyter/jupyterServerInstallation';
|
|
import { powershellDisplayName, pysparkDisplayName, python3DisplayName, sparkRDisplayName, sparkScalaDisplayName, winPlatform } from '../../common/constants';
|
|
|
|
describe('Jupyter Server Installation', function () {
|
|
let outputChannelStub: TypeMoq.IMock<vscode.OutputChannel>;
|
|
let installation: JupyterServerInstallation;
|
|
|
|
beforeEach(function (): void {
|
|
outputChannelStub = TypeMoq.Mock.ofType<vscode.OutputChannel>();
|
|
outputChannelStub.setup(c => c.show(TypeMoq.It.isAny()));
|
|
outputChannelStub.setup(c => c.appendLine(TypeMoq.It.isAnyString()));
|
|
|
|
installation = new JupyterServerInstallation('', outputChannelStub.object);
|
|
installation.execOptions = { env: Object.assign({}, process.env) };
|
|
});
|
|
|
|
afterEach(function (): void {
|
|
sinon.restore();
|
|
});
|
|
|
|
it('Getters and setters', async function() {
|
|
let pythonPath = installation.pythonInstallationPath;
|
|
should(pythonPath).be.equal(JupyterServerInstallation.getPythonInstallPath());
|
|
});
|
|
|
|
it('Get pip packages', async function() {
|
|
// Should return nothing if passed an invalid python path
|
|
let fakePath = uuid.v4();
|
|
let pkgResult = await installation.getInstalledPipPackages(fakePath);
|
|
should(pkgResult).not.be.undefined();
|
|
should(pkgResult.length).be.equal(0);
|
|
|
|
// Should return nothing if python is not installed
|
|
sinon.stub(JupyterServerInstallation, 'isPythonInstalled').returns(false);
|
|
pkgResult = await installation.getInstalledPipPackages();
|
|
should(pkgResult).not.be.undefined();
|
|
should(pkgResult.length).be.equal(0);
|
|
|
|
// Should return nothing on error
|
|
sinon.restore();
|
|
sinon.stub(JupyterServerInstallation, 'isPythonInstalled').returns(true);
|
|
sinon.stub(utils, 'executeBufferedCommand').rejects(new Error('Expected test failure.'));
|
|
pkgResult = await installation.getInstalledPipPackages();
|
|
should(pkgResult).not.be.undefined();
|
|
should(pkgResult.length).be.equal(0);
|
|
outputChannelStub.verify(c => c.appendLine(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
|
|
|
|
// Normal use case
|
|
sinon.restore();
|
|
let testPackages: PythonPkgDetails[] = [{
|
|
name: 'TestPkg1',
|
|
version: '1.2.3'
|
|
}, {
|
|
name: 'TestPkg2',
|
|
version: '4.5.6'
|
|
}];
|
|
sinon.stub(JupyterServerInstallation, 'isPythonInstalled').returns(true);
|
|
sinon.stub(utils, 'executeBufferedCommand').resolves(JSON.stringify(testPackages));
|
|
pkgResult = await installation.getInstalledPipPackages();
|
|
should(pkgResult).be.deepEqual(testPackages);
|
|
});
|
|
|
|
it('Install pip package', async function() {
|
|
let commandStub = sinon.stub(utils, 'executeStreamedCommand').resolves();
|
|
|
|
// Should not execute any commands when passed an empty package list
|
|
await installation.installPipPackages(undefined, false);
|
|
should(commandStub.called).be.false();
|
|
|
|
await installation.installPipPackages([], false);
|
|
should(commandStub.called).be.false();
|
|
|
|
// Install package using exact version
|
|
let testPackages = [{
|
|
name: 'TestPkg1',
|
|
version: '1.2.3'
|
|
}, {
|
|
name: 'TestPkg2',
|
|
version: '4.5.6'
|
|
}];
|
|
await installation.installPipPackages(testPackages, false);
|
|
should(commandStub.calledOnce).be.true();
|
|
let commandStr = commandStub.args[0][0] as string;
|
|
should(commandStr.includes('"TestPkg1==1.2.3" "TestPkg2==4.5.6"')).be.true();
|
|
|
|
// Install package using minimum version
|
|
await installation.installPipPackages(testPackages, true);
|
|
should(commandStub.calledTwice).be.true();
|
|
commandStr = commandStub.args[1][0] as string;
|
|
should(commandStr.includes('"TestPkg1>=1.2.3" "TestPkg2>=4.5.6"')).be.true();
|
|
});
|
|
|
|
it('Uninstall pip package', async function() {
|
|
let commandStub = sinon.stub(utils, 'executeStreamedCommand').resolves();
|
|
|
|
let testPackages = [{
|
|
name: 'jupyter',
|
|
version: '1.0.0'
|
|
}, {
|
|
name: 'TestPkg2',
|
|
version: '4.5.6'
|
|
}];
|
|
await installation.uninstallPipPackages(testPackages);
|
|
should(commandStub.calledOnce).be.true();
|
|
let commandStr = commandStub.args[0][0] as string;
|
|
should(commandStr.includes('"jupyter==1.0.0" "TestPkg2==4.5.6"')).be.true();
|
|
});
|
|
|
|
it('Get conda packages', async function() {
|
|
// Should return nothing if conda is not installed
|
|
sinon.stub(fs, 'existsSync').returns(false);
|
|
let pkgResult = await installation.getInstalledCondaPackages();
|
|
should(pkgResult).not.be.undefined();
|
|
should(pkgResult.length).be.equal(0);
|
|
|
|
// Should return nothing on error
|
|
sinon.restore();
|
|
sinon.stub(fs, 'existsSync').returns(true);
|
|
sinon.stub(utils, 'executeBufferedCommand').rejects(new Error('Expected test failure.'));
|
|
pkgResult = await installation.getInstalledCondaPackages();
|
|
should(pkgResult).not.be.undefined();
|
|
should(pkgResult.length).be.equal(0);
|
|
outputChannelStub.verify(c => c.appendLine(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
|
|
|
|
// Normal use case
|
|
sinon.restore();
|
|
let testPackages: PythonPkgDetails[] = [{
|
|
name: 'TestPkg1',
|
|
version: '1.2.3',
|
|
channel: 'conda'
|
|
}, {
|
|
name: 'TestPkg2',
|
|
version: '4.5.6',
|
|
channel: 'pypi'
|
|
}, {
|
|
name: 'TestPkg3',
|
|
version: '7.8.9',
|
|
channel: 'conda'
|
|
}];
|
|
sinon.stub(fs, 'existsSync').returns(true);
|
|
sinon.stub(utils, 'executeBufferedCommand').resolves(JSON.stringify(testPackages));
|
|
pkgResult = await installation.getInstalledCondaPackages();
|
|
let filteredPackages = testPackages.filter(pkg => pkg.channel !== 'pypi');
|
|
should(pkgResult).be.deepEqual(filteredPackages);
|
|
});
|
|
|
|
it('Install conda package', async function() {
|
|
let commandStub = sinon.stub(utils, 'executeStreamedCommand').resolves();
|
|
|
|
// Should not execute any commands when passed an empty package list
|
|
await installation.installCondaPackages(undefined, false);
|
|
should(commandStub.called).be.false();
|
|
|
|
await installation.installCondaPackages([], false);
|
|
should(commandStub.called).be.false();
|
|
|
|
// Install package using exact version
|
|
let testPackages = [{
|
|
name: 'TestPkg1',
|
|
version: '1.2.3'
|
|
}, {
|
|
name: 'TestPkg2',
|
|
version: '4.5.6'
|
|
}];
|
|
await installation.installCondaPackages(testPackages, false);
|
|
should(commandStub.calledOnce).be.true();
|
|
let commandStr = commandStub.args[0][0] as string;
|
|
should(commandStr.includes('"TestPkg1==1.2.3" "TestPkg2==4.5.6"')).be.true();
|
|
|
|
// Install package using minimum version
|
|
await installation.installCondaPackages(testPackages, true);
|
|
should(commandStub.calledTwice).be.true();
|
|
commandStr = commandStub.args[1][0] as string;
|
|
should(commandStr.includes('"TestPkg1>=1.2.3" "TestPkg2>=4.5.6"')).be.true();
|
|
});
|
|
|
|
it('Uninstall conda package', async function() {
|
|
let commandStub = sinon.stub(utils, 'executeStreamedCommand').resolves();
|
|
|
|
let testPackages = [{
|
|
name: 'jupyter',
|
|
version: '1.0.0'
|
|
}, {
|
|
name: 'TestPkg2',
|
|
version: '4.5.6'
|
|
}];
|
|
await installation.uninstallCondaPackages(testPackages);
|
|
should(commandStub.calledOnce).be.true();
|
|
let commandStr = commandStub.args[0][0] as string;
|
|
should(commandStr.includes('"jupyter==1.0.0" "TestPkg2==4.5.6"')).be.true();
|
|
});
|
|
|
|
it('Get required packages test - Undefined argument', async function() {
|
|
let packages = installation.getRequiredPackagesForKernel(undefined);
|
|
should(packages).not.be.undefined();
|
|
should(packages.length).be.equal(0);
|
|
});
|
|
|
|
it('Get required packages test - Fake kernel', async function() {
|
|
let packages = installation.getRequiredPackagesForKernel('NotARealKernel');
|
|
should(packages).not.be.undefined();
|
|
should(packages.length).be.equal(0);
|
|
});
|
|
|
|
it('Get required packages test - Python 3 kernel', async function() {
|
|
let expectedPackages: PythonPkgDetails[] = [{
|
|
name: 'jupyter',
|
|
version: '1.0.0'
|
|
}];
|
|
let packages = installation.getRequiredPackagesForKernel(python3DisplayName);
|
|
should(packages).be.deepEqual(expectedPackages);
|
|
});
|
|
|
|
it('Get required packages test - Powershell kernel', async function() {
|
|
let expectedPackages = [{
|
|
name: 'jupyter',
|
|
version: '1.0.0'
|
|
}, {
|
|
name: 'powershell-kernel',
|
|
version: '0.1.3'
|
|
}];
|
|
let packages = installation.getRequiredPackagesForKernel(powershellDisplayName);
|
|
should(packages).be.deepEqual(expectedPackages);
|
|
});
|
|
|
|
it('Get required packages test - Spark kernels', async function() {
|
|
let expectedPackages = [{
|
|
name: 'jupyter',
|
|
version: '1.0.0'
|
|
}, {
|
|
name: 'sparkmagic',
|
|
version: '0.12.9'
|
|
}, {
|
|
name: 'pandas',
|
|
version: '0.24.2'
|
|
}, {
|
|
name: 'prose-codeaccelerator',
|
|
version: '1.3.0'
|
|
}];
|
|
let packages = installation.getRequiredPackagesForKernel(pysparkDisplayName);
|
|
should(packages).be.deepEqual(expectedPackages, "Unexpected packages for PySpark kernel.");
|
|
|
|
packages = installation.getRequiredPackagesForKernel(sparkScalaDisplayName);
|
|
should(packages).be.deepEqual(expectedPackages, "Unexpected packages for Spark Scala kernel.");
|
|
|
|
packages = installation.getRequiredPackagesForKernel(sparkRDisplayName);
|
|
should(packages).be.deepEqual(expectedPackages, "Unexpected packages for Spark R kernel.");
|
|
});
|
|
|
|
it('Install python test - Run install while Python is already running', async function() {
|
|
// Should reject overwriting an existing python install if running on Windows and python is currently running.
|
|
if (process.platform === winPlatform) {
|
|
sinon.stub(utils, 'executeBufferedCommand').resolves('python.exe');
|
|
|
|
let installSettings: PythonInstallSettings = {
|
|
installPath: `${process.env['USERPROFILE']}\\ads-python`,
|
|
existingPython: false,
|
|
packages: []
|
|
};
|
|
await should(installation.startInstallProcess(false, installSettings)).be.rejected();
|
|
}
|
|
});
|
|
|
|
it('Install python test - Run install with existing Python instance', async function() {
|
|
let installSettings: PythonInstallSettings = {
|
|
installPath: `${process.env['USERPROFILE']}\\ads-python`,
|
|
existingPython: true,
|
|
packages: installation.getRequiredPackagesForKernel(python3DisplayName)
|
|
};
|
|
|
|
sinon.stub(utils, 'exists').resolves(true);
|
|
sinon.stub(fs, 'existsSync').returns(false);
|
|
sinon.stub(utils, 'executeBufferedCommand').resolves(`${installSettings.installPath}\\site-packages`);
|
|
|
|
// Both of these are called from upgradePythonPackages
|
|
sinon.stub(installation, 'getInstalledPipPackages').resolves([]);
|
|
let pipInstallStub = sinon.stub(installation, 'installPipPackages').resolves();
|
|
|
|
let httpRequestSpy = sinon.spy(request, 'get');
|
|
|
|
await should(installation.startInstallProcess(false, installSettings)).be.resolved();
|
|
|
|
should(httpRequestSpy.callCount).be.equal(0);
|
|
should(pipInstallStub.callCount).be.equal(1);
|
|
|
|
let packagesToInstall = pipInstallStub.firstCall.args[0] as PythonPkgDetails[];
|
|
should(packagesToInstall).be.deepEqual(installation.getRequiredPackagesForKernel(python3DisplayName));
|
|
});
|
|
});
|