mirror of
https://github.com/ckaczor/azuredatastudio.git
synced 2026-02-16 18:46:40 -05:00
Manage Package Dialog Refactor (#8473)
* Refactoring Manage Packages dialog so that other extensions can contribute to it by registering package mange providers for different location and package type
This commit is contained in:
Leila Lali
@@ -0,0 +1,229 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* 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 should from 'should';
|
||||
import 'mocha';
|
||||
import * as TypeMoq from 'typemoq';
|
||||
import { JupyterServerInstallation, PythonPkgDetails, IJupyterServerInstallation } from '../../jupyter/jupyterServerInstallation';
|
||||
import { LocalCondaPackageManageProvider } from '../../jupyter/localCondaPackageManageProvider';
|
||||
import * as constants from '../../common/constants';
|
||||
import { LocalPipPackageManageProvider } from '../../jupyter/localPipPackageManageProvider';
|
||||
import { IPiPyClient, PiPyClient } from '../../jupyter/pipyClient';
|
||||
|
||||
interface TestContext {
|
||||
serverInstallation: IJupyterServerInstallation;
|
||||
piPyClient: IPiPyClient;
|
||||
}
|
||||
|
||||
describe('Manage Package Providers', () => {
|
||||
|
||||
it('Conda should return valid package target', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let provider = new LocalCondaPackageManageProvider(serverInstallation.object);
|
||||
should.deepEqual(provider.packageTarget, { location: constants.localhostName, packageType: constants.PythonPkgType.Anaconda });
|
||||
});
|
||||
|
||||
it('Pip should return valid package target', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let client = createPipyClient(testContext);
|
||||
let provider = new LocalPipPackageManageProvider(serverInstallation.object, client.object);
|
||||
should.deepEqual(provider.packageTarget, { location: constants.localhostName, packageType: constants.PythonPkgType.Pip });
|
||||
});
|
||||
|
||||
it('Pip listPackages should return valid packages', async function (): Promise<void> {
|
||||
let packages = [
|
||||
{
|
||||
name: 'name1',
|
||||
version: '1.1.1.1'
|
||||
}
|
||||
];
|
||||
let testContext = createContext();
|
||||
testContext.serverInstallation.getInstalledPipPackages = () => {
|
||||
return Promise.resolve(packages);
|
||||
};
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let client = createPipyClient(testContext);
|
||||
let provider = new LocalPipPackageManageProvider(serverInstallation.object, client.object);
|
||||
|
||||
should.deepEqual(await provider.listPackages(), packages);
|
||||
});
|
||||
|
||||
it('Conda listPackages should return valid packages', async function (): Promise<void> {
|
||||
let packages = [
|
||||
{
|
||||
name: 'name1',
|
||||
version: '1.1.1.1'
|
||||
}
|
||||
];
|
||||
let testContext = createContext();
|
||||
testContext.serverInstallation.getInstalledCondaPackages = () => {
|
||||
return Promise.resolve(packages);
|
||||
};
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let provider = new LocalCondaPackageManageProvider(serverInstallation.object);
|
||||
|
||||
let actual = await provider.listPackages();
|
||||
should.deepEqual(actual, packages);
|
||||
});
|
||||
|
||||
it('Pip installPackages should install packages successfully', async function (): Promise<void> {
|
||||
let packages = [
|
||||
{
|
||||
name: 'name1',
|
||||
version: '1.1.1.1'
|
||||
}
|
||||
];
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let client = createPipyClient(testContext);
|
||||
let provider = new LocalPipPackageManageProvider(serverInstallation.object, client.object);
|
||||
|
||||
await provider.installPackages(packages, true);
|
||||
serverInstallation.verify(x => x.installPipPackages(packages, true), TypeMoq.Times.once());
|
||||
});
|
||||
|
||||
it('Conda installPackages should install packages successfully', async function (): Promise<void> {
|
||||
let packages = [
|
||||
{
|
||||
name: 'name1',
|
||||
version: '1.1.1.1'
|
||||
}
|
||||
];
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let provider = new LocalCondaPackageManageProvider(serverInstallation.object);
|
||||
|
||||
await provider.installPackages(packages, true);
|
||||
serverInstallation.verify(x => x.installCondaPackages(packages, true), TypeMoq.Times.once());
|
||||
});
|
||||
|
||||
it('Pip uninstallPackages should install packages successfully', async function (): Promise<void> {
|
||||
let packages = [
|
||||
{
|
||||
name: 'name1',
|
||||
version: '1.1.1.1'
|
||||
}
|
||||
];
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let client = createPipyClient(testContext);
|
||||
let provider = new LocalPipPackageManageProvider(serverInstallation.object, client.object);
|
||||
|
||||
await provider.uninstallPackages(packages);
|
||||
serverInstallation.verify(x => x.uninstallPipPackages(packages), TypeMoq.Times.once());
|
||||
});
|
||||
|
||||
it('Conda uninstallPackages should install packages successfully', async function (): Promise<void> {
|
||||
let packages = [
|
||||
{
|
||||
name: 'name1',
|
||||
version: '1.1.1.1'
|
||||
}
|
||||
];
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let provider = new LocalCondaPackageManageProvider(serverInstallation.object);
|
||||
|
||||
await provider.uninstallPackages(packages);
|
||||
serverInstallation.verify(x => x.uninstallCondaPackages(packages), TypeMoq.Times.once());
|
||||
});
|
||||
|
||||
it('Conda canUseProvider should return what the server is returning', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let provider = new LocalCondaPackageManageProvider(serverInstallation.object);
|
||||
|
||||
should.equal(await provider.canUseProvider(), false);
|
||||
});
|
||||
|
||||
it('Pip canUseProvider should return true', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let client = createPipyClient(testContext);
|
||||
let provider = new LocalPipPackageManageProvider(serverInstallation.object, client.object);
|
||||
|
||||
should.equal(await provider.canUseProvider(), true);
|
||||
});
|
||||
|
||||
it('Pip getPackageOverview should return package info successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
testContext.piPyClient.fetchPypiPackage = (packageName) => {
|
||||
return Promise.resolve(`
|
||||
"{"info":{"summary":"package summary"}, "releases":{"0.0.1":[{"comment_text":""}], "0.0.2":[{"comment_text":""}]}"`);
|
||||
};
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
let client = createPipyClient(testContext);
|
||||
let provider = new LocalPipPackageManageProvider(serverInstallation.object, client.object);
|
||||
|
||||
should(provider.getPackageOverview('name')).resolvedWith({
|
||||
name: 'name',
|
||||
versions: ['0.0.1', '0.0.2'],
|
||||
summary: 'summary'
|
||||
});
|
||||
});
|
||||
|
||||
it('Conda getPackageOverview should return package info successfully', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
testContext.serverInstallation.executeBufferedCommand = (command) => {
|
||||
return Promise.resolve(`
|
||||
"{"name":[{"version":"0.0.1"}, {"version":"0.0.2}]"`);
|
||||
};
|
||||
let serverInstallation = createJupyterServerInstallation(testContext);
|
||||
|
||||
let provider = new LocalCondaPackageManageProvider(serverInstallation.object);
|
||||
|
||||
should(provider.getPackageOverview('name')).resolvedWith({
|
||||
name: 'name',
|
||||
versions: ['0.0.1', '0.0.2'],
|
||||
summary: undefined
|
||||
});
|
||||
});
|
||||
|
||||
function createContext(): TestContext {
|
||||
return {
|
||||
serverInstallation: {
|
||||
installCondaPackages: (packages: PythonPkgDetails[], useMinVersion: boolean) => { return Promise.resolve(); },
|
||||
configurePackagePaths: () => { return Promise.resolve(); },
|
||||
startInstallProcess: (forceInstall: boolean, installSettings?: { installPath: string, existingPython: boolean }) => { return Promise.resolve(); },
|
||||
getInstalledPipPackages: () => { return Promise.resolve([]); },
|
||||
installPipPackages: (packages: PythonPkgDetails[], useMinVersion: boolean) => { return Promise.resolve(); },
|
||||
uninstallPipPackages: (packages: PythonPkgDetails[]) => { return Promise.resolve(); },
|
||||
getInstalledCondaPackages: () => { return Promise.resolve([]); },
|
||||
uninstallCondaPackages: (packages: PythonPkgDetails[]) => { return Promise.resolve(); },
|
||||
executeBufferedCommand: (command: string) => { return Promise.resolve(''); },
|
||||
executeStreamedCommand: (command: string) => { return Promise.resolve(); },
|
||||
getCondaExePath: () => { return ''; },
|
||||
pythonExecutable: '',
|
||||
usingConda: false
|
||||
},
|
||||
piPyClient: {
|
||||
fetchPypiPackage: (packageName) => { return Promise.resolve(); }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function createJupyterServerInstallation(testContext: TestContext): TypeMoq.IMock<JupyterServerInstallation> {
|
||||
let mockInstance = TypeMoq.Mock.ofType(JupyterServerInstallation);
|
||||
mockInstance.setup(x => x.installCondaPackages(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((packages, useMinVersion) => testContext.serverInstallation.installCondaPackages(packages, useMinVersion));
|
||||
mockInstance.setup(x => x.installPipPackages(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((packages, useMinVersion) => testContext.serverInstallation.installPipPackages(packages, useMinVersion));
|
||||
mockInstance.setup(x => x.uninstallCondaPackages(TypeMoq.It.isAny())).returns((packages, useMinVersion) => testContext.serverInstallation.uninstallCondaPackages(packages));
|
||||
mockInstance.setup(x => x.uninstallPipPackages(TypeMoq.It.isAny())).returns((packages, useMinVersion) => testContext.serverInstallation.uninstallPipPackages(packages));
|
||||
mockInstance.setup(x => x.getInstalledPipPackages()).returns(() => testContext.serverInstallation.getInstalledPipPackages());
|
||||
mockInstance.setup(x => x.getInstalledCondaPackages()).returns(() => testContext.serverInstallation.getInstalledCondaPackages());
|
||||
mockInstance.setup(x => x.usingConda).returns(() => testContext.serverInstallation.usingConda);
|
||||
return mockInstance;
|
||||
}
|
||||
|
||||
function createPipyClient(testContext: TestContext): TypeMoq.IMock<IPiPyClient> {
|
||||
let mockInstance = TypeMoq.Mock.ofType(PiPyClient);
|
||||
mockInstance.setup(x => x.fetchPypiPackage(TypeMoq.It.isAny())).returns((packageName) =>
|
||||
testContext.piPyClient.fetchPypiPackage(packageName));
|
||||
return mockInstance;
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,351 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* 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 should from 'should';
|
||||
import 'mocha';
|
||||
import * as TypeMoq from 'typemoq';
|
||||
import { IPackageManageProvider, IPackageDetails } from '../../types';
|
||||
import { LocalPipPackageManageProvider } from '../../jupyter/localPipPackageManageProvider';
|
||||
|
||||
import { ManagePackagesDialogModel } from '../../dialog/managePackages/managePackagesDialogModel';
|
||||
import { JupyterServerInstallation } from '../../jupyter/jupyterServerInstallation';
|
||||
|
||||
interface TestContext {
|
||||
provider: IPackageManageProvider;
|
||||
}
|
||||
|
||||
describe('Manage Packages', () => {
|
||||
let jupyterServerInstallation: JupyterServerInstallation;
|
||||
beforeEach(() => {
|
||||
jupyterServerInstallation = new JupyterServerInstallation(undefined, undefined, undefined, undefined);
|
||||
});
|
||||
|
||||
it('Should throw exception given undefined providers', async function (): Promise<void> {
|
||||
should.throws(() => { new ManagePackagesDialogModel(jupyterServerInstallation, undefined); }, 'Invalid list of package manager providers');
|
||||
});
|
||||
|
||||
it('Should throw exception given empty providers', async function (): Promise<void> {
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
should.throws(() => { new ManagePackagesDialogModel(jupyterServerInstallation, providers); }, 'Invalid list of package manager providers');
|
||||
});
|
||||
|
||||
it('Should not throw exception given undefined options', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
testContext.provider.listPackages = () => {
|
||||
return Promise.resolve(undefined);
|
||||
};
|
||||
let provider = createProvider(testContext);
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(provider.providerId, provider);
|
||||
|
||||
should.doesNotThrow(() => { new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined); });
|
||||
});
|
||||
|
||||
it('Init should throw exception given invalid default location', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let provider = createProvider(testContext);
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(provider.providerId, provider);
|
||||
|
||||
let options = {
|
||||
multiLocations: true,
|
||||
defaultLocation: 'invalid location'
|
||||
};
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, options);
|
||||
should(model.init()).rejectedWith(`Invalid default location '${options.defaultLocation}`);
|
||||
});
|
||||
|
||||
it('Init should throw exception given invalid default provider', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let provider = createProvider(testContext);
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(provider.providerId, provider);
|
||||
|
||||
let options = {
|
||||
multiLocations: true,
|
||||
defaultProviderId: 'invalid provider'
|
||||
};
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, options);
|
||||
should(model.init()).rejectedWith(`Invalid default provider id '${options.defaultProviderId}`);
|
||||
});
|
||||
|
||||
it('Init should throw exception not given valid default location for single location mode', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let provider = createProvider(testContext);
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(provider.providerId, provider);
|
||||
|
||||
let options = {
|
||||
multiLocations: false
|
||||
};
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, options);
|
||||
should(model.init()).rejectedWith(`Default location not specified for single location mode`);
|
||||
});
|
||||
|
||||
|
||||
it('Init should set default options given undefined', async function (): Promise<void> {
|
||||
let testContext = createContext();
|
||||
let provider = createProvider(testContext);
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(provider.providerId, provider);
|
||||
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined);
|
||||
|
||||
await model.init();
|
||||
should.equal(model.multiLocationMode, true);
|
||||
should.equal(model.defaultLocation, provider.packageTarget.location);
|
||||
should.equal(model.defaultProviderId, provider.providerId);
|
||||
});
|
||||
|
||||
it('Init should set default provider Id given valid options', async function (): Promise<void> {
|
||||
let testContext1 = createContext();
|
||||
testContext1.provider.providerId = 'providerId1';
|
||||
testContext1.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
|
||||
let testContext2 = createContext();
|
||||
testContext2.provider.providerId = 'providerId2';
|
||||
testContext2.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type2'
|
||||
};
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(testContext1.provider.providerId, createProvider(testContext1));
|
||||
providers.set(testContext2.provider.providerId, createProvider(testContext2));
|
||||
let options = {
|
||||
multiLocations: false,
|
||||
defaultLocation: testContext2.provider.packageTarget.location,
|
||||
defaultProviderId: testContext2.provider.providerId
|
||||
};
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, options);
|
||||
|
||||
await model.init();
|
||||
should.equal(model.multiLocationMode, false);
|
||||
should.equal(model.defaultLocation, testContext2.provider.packageTarget.location);
|
||||
should.equal(model.defaultProviderId, testContext2.provider.providerId);
|
||||
});
|
||||
|
||||
it('Should create a cache for multiple providers successfully', async function (): Promise<void> {
|
||||
let testContext1 = createContext();
|
||||
testContext1.provider.providerId = 'providerId1';
|
||||
testContext1.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
|
||||
let testContext2 = createContext();
|
||||
testContext2.provider.providerId = 'providerId2';
|
||||
testContext2.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type2'
|
||||
};
|
||||
|
||||
let testContext3 = createContext();
|
||||
testContext3.provider.providerId = 'providerId3';
|
||||
testContext3.provider.packageTarget = {
|
||||
location: 'location2',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(testContext1.provider.providerId, createProvider(testContext1));
|
||||
providers.set(testContext2.provider.providerId, createProvider(testContext2));
|
||||
providers.set(testContext3.provider.providerId, createProvider(testContext3));
|
||||
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined);
|
||||
|
||||
await model.init();
|
||||
should.equal(model.defaultLocation, testContext1.provider.packageTarget.location);
|
||||
should.deepEqual(model.getPackageTypes('location1'), [{ providerId: 'providerId1', packageType: 'package-type1'}, {providerId: 'providerId2', packageType: 'package-type2'}]);
|
||||
should.deepEqual(model.getPackageTypes('location2'), [{providerId: 'providerId3', packageType: 'package-type1'}]);
|
||||
});
|
||||
|
||||
it('Should not include a provider that can not be used in current context', async function (): Promise<void> {
|
||||
let testContext1 = createContext();
|
||||
testContext1.provider.providerId = 'providerId1';
|
||||
testContext1.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
|
||||
let testContext2 = createContext();
|
||||
testContext2.provider.providerId = 'providerId2';
|
||||
testContext2.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type2'
|
||||
};
|
||||
testContext2.provider.canUseProvider = () => { return Promise.resolve(false); };
|
||||
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(testContext1.provider.providerId, createProvider(testContext1));
|
||||
providers.set(testContext2.provider.providerId, createProvider(testContext2));
|
||||
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined);
|
||||
|
||||
await model.init();
|
||||
should.equal(model.defaultLocation, testContext1.provider.packageTarget.location);
|
||||
should.deepEqual(model.getPackageTypes('location1'), [{providerId: 'providerId1', packageType: 'package-type1'}]);
|
||||
});
|
||||
|
||||
it('changeProvider should change current provider successfully', async function (): Promise<void> {
|
||||
let testContext1 = createContext();
|
||||
testContext1.provider.providerId = 'providerId1';
|
||||
testContext1.provider.getLocationTitle = () => Promise.resolve('location title 1');
|
||||
testContext1.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
|
||||
let testContext2 = createContext();
|
||||
testContext2.provider.providerId = 'providerId2';
|
||||
testContext2.provider.getLocationTitle = () => Promise.resolve('location title 2');
|
||||
testContext2.provider.packageTarget = {
|
||||
location: 'location2',
|
||||
packageType: 'package-type2'
|
||||
};
|
||||
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(testContext1.provider.providerId, createProvider(testContext1));
|
||||
providers.set(testContext2.provider.providerId, createProvider(testContext2));
|
||||
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined);
|
||||
|
||||
await model.init();
|
||||
model.changeProvider('providerId2');
|
||||
should.deepEqual(await model.getLocationTitle(), 'location title 2');
|
||||
});
|
||||
|
||||
it('changeProvider should throw exception given invalid provider', async function (): Promise<void> {
|
||||
let testContext1 = createContext();
|
||||
testContext1.provider.providerId = 'providerId1';
|
||||
testContext1.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
|
||||
let testContext2 = createContext();
|
||||
testContext2.provider.providerId = 'providerId2';
|
||||
testContext2.provider.packageTarget = {
|
||||
location: 'location2',
|
||||
packageType: 'package-type2'
|
||||
};
|
||||
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(testContext1.provider.providerId, createProvider(testContext1));
|
||||
providers.set(testContext2.provider.providerId, createProvider(testContext2));
|
||||
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined);
|
||||
|
||||
await model.init();
|
||||
should.throws(() => model.changeProvider('providerId3'));
|
||||
});
|
||||
|
||||
|
||||
it('currentPackageManageProvider should return undefined if current provider is not set', async function (): Promise<void> {
|
||||
let testContext1 = createContext();
|
||||
testContext1.provider.providerId = 'providerId1';
|
||||
testContext1.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
|
||||
let testContext2 = createContext();
|
||||
testContext2.provider.providerId = 'providerId2';
|
||||
testContext2.provider.packageTarget = {
|
||||
location: 'location2',
|
||||
packageType: 'package-type2'
|
||||
};
|
||||
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(testContext1.provider.providerId, createProvider(testContext1));
|
||||
providers.set(testContext2.provider.providerId, createProvider(testContext2));
|
||||
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined);
|
||||
|
||||
should.equal(model.currentPackageManageProvider, undefined);
|
||||
should(model.listPackages()).rejected();
|
||||
should(model.installPackages(TypeMoq.It.isAny())).rejected();
|
||||
should(model.uninstallPackages(TypeMoq.It.isAny())).rejected();
|
||||
});
|
||||
|
||||
it('current provider should install and uninstall packages successfully', async function (): Promise<void> {
|
||||
let testContext1 = createContext();
|
||||
testContext1.provider.providerId = 'providerId1';
|
||||
testContext1.provider.packageTarget = {
|
||||
location: 'location1',
|
||||
packageType: 'package-type1'
|
||||
};
|
||||
|
||||
let testContext2 = createContext();
|
||||
testContext2.provider.providerId = 'providerId2';
|
||||
testContext2.provider.getLocationTitle = () => Promise.resolve('location title 2');
|
||||
testContext2.provider.packageTarget = {
|
||||
location: 'location2',
|
||||
packageType: 'package-type2'
|
||||
};
|
||||
let packages = [
|
||||
{
|
||||
name: 'p1',
|
||||
version: '1.1.1.1'
|
||||
},
|
||||
{
|
||||
name: 'p2',
|
||||
version: '1.1.1.2'
|
||||
}
|
||||
];
|
||||
testContext2.provider.listPackages = () => {
|
||||
return Promise.resolve(packages);
|
||||
};
|
||||
|
||||
let providers = new Map<string, IPackageManageProvider>();
|
||||
providers.set(testContext1.provider.providerId, createProvider(testContext1));
|
||||
providers.set(testContext2.provider.providerId, createProvider(testContext2));
|
||||
|
||||
let model = new ManagePackagesDialogModel(jupyterServerInstallation, providers, undefined);
|
||||
|
||||
await model.init();
|
||||
model.changeProvider('providerId2');
|
||||
should(model.listPackages()).resolvedWith(packages);
|
||||
should(model.installPackages(packages)).resolved();
|
||||
should(model.uninstallPackages(packages)).resolved();
|
||||
should(model.getPackageOverview('p1')).resolved();
|
||||
should(model.getLocationTitle()).rejectedWith('location title 2');
|
||||
});
|
||||
|
||||
function createContext(): TestContext {
|
||||
return {
|
||||
provider: {
|
||||
providerId: 'providerId',
|
||||
packageTarget: {
|
||||
location: 'location',
|
||||
packageType: 'package-type'
|
||||
},
|
||||
canUseProvider: () => { return Promise.resolve(true); },
|
||||
getLocationTitle: () => { return Promise.resolve('location-title'); },
|
||||
installPackages:() => { return Promise.resolve(); },
|
||||
uninstallPackages: (packages: IPackageDetails[]) => { return Promise.resolve(); },
|
||||
listPackages: () => { return Promise.resolve([]); },
|
||||
getPackageOverview: (name: string) => { return Promise.resolve(undefined); },
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function createProvider(testContext: TestContext): IPackageManageProvider {
|
||||
let mockProvider = TypeMoq.Mock.ofType(LocalPipPackageManageProvider);
|
||||
mockProvider.setup(x => x.canUseProvider()).returns(() => testContext.provider.canUseProvider());
|
||||
mockProvider.setup(x => x.getLocationTitle()).returns(() => testContext.provider.getLocationTitle());
|
||||
mockProvider.setup(x => x.installPackages(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((packages, useMinVersion) => testContext.provider.installPackages(packages, useMinVersion));
|
||||
mockProvider.setup(x => x.uninstallPackages(TypeMoq.It.isAny())).returns((packages) => testContext.provider.uninstallPackages(packages));
|
||||
mockProvider.setup(x => x.listPackages()).returns(() => testContext.provider.listPackages());
|
||||
mockProvider.setup(x => x.getPackageOverview(TypeMoq.It.isAny())).returns((name) => testContext.provider.getPackageOverview(name));
|
||||
mockProvider.setup(x => x.packageTarget).returns(() => testContext.provider.packageTarget);
|
||||
mockProvider.setup(x => x.providerId).returns(() => testContext.provider.providerId);
|
||||
return mockProvider.object;
|
||||
}
|
||||
|
||||
});
|
||||
Reference in New Issue
Block a user