Machine Learning Services R Packages (#8870)

* R Package management in Machine learning services extension

extensions/machine-learning-services/src/test/common/processService.test.ts

@@ -29,11 +29,11 @@ function createContext(): TestContext {
 	};
 }
 
-function execFolderListCommand(context: TestContext, service : ProcessService): Promise<void> {
+function execFolderListCommand(context: TestContext, service : ProcessService): Promise<string> {
 	if (utils.isWindows()) {
-		return service.execScripts('cmd', ['dir', '.'], context.outputChannel);
+		return service.execScripts('cmd', ['dir', '.'], [], context.outputChannel);
 	} else {
-		return service.execScripts('/bin/sh', ['-c', 'ls'], context.outputChannel);
+		return service.execScripts('/bin/sh', ['-c', 'ls'], [], context.outputChannel);
 	}
 }
 

extensions/machine-learning-services/src/test/mainController.test.ts

@@ -15,9 +15,13 @@ import { QueryRunner } from '../common/queryRunner';
 import { ProcessService } from '../common/processService';
 import MainController from '../controllers/mainController';
 import { PackageManager } from '../packageManagement/packageManager';
+import * as nbExtensionApis from '../typings/notebookServices';
 
 interface TestContext {
-
+	notebookExtension: vscode.Extension<any>;
+	jupyterInstallation: nbExtensionApis.IJupyterServerInstallation;
+	jupyterController: nbExtensionApis.IJupyterController;
+	nbExtensionApis: nbExtensionApis.IExtensionApi;
 	apiWrapper: TypeMoq.IMock<ApiWrapper>;
 	queryRunner: TypeMoq.IMock<QueryRunner>;
 	processService: TypeMoq.IMock<ProcessService>;
@@ -25,11 +29,49 @@ interface TestContext {
 	outputChannel: vscode.OutputChannel;
 	extension: vscode.Extension<any>;
 	packageManager: TypeMoq.IMock<PackageManager>;
+	workspaceConfig: vscode.WorkspaceConfiguration;
 }
 
 function createContext(): TestContext {
+	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
+	};
+
 	let extensionPath = path.join(__dirname, '..', '..');
+	let extensionApi: nbExtensionApis.IExtensionApi = {
+		getJupyterController: () => { return jupyterController; },
+		registerPackageManager: (providerId: string, packageManagerProvider: nbExtensionApis.IPackageManageProvider) => {
+			packages.set(providerId, packageManagerProvider);
+		},
+		getPackageManagers: () => { return packages; },
+	};
 	return {
+		jupyterInstallation: jupyterInstallation,
+		jupyterController: jupyterController,
+		nbExtensionApis: extensionApi,
+		notebookExtension: {
+			id: '',
+			extensionPath: '',
+			isActive: true,
+			packageJSON: '',
+			extensionKind: vscode.ExtensionKind.UI,
+			exports: extensionApi,
+			activate: () => {return Promise.resolve();}
+		},
 		apiWrapper: TypeMoq.Mock.ofType(ApiWrapper),
 		queryRunner: TypeMoq.Mock.ofType(QueryRunner),
 		processService: TypeMoq.Mock.ofType(ProcessService),
@@ -67,6 +109,12 @@ function createContext(): TestContext {
 			extensionKind: vscode.ExtensionKind.UI,
 			exports: {},
 			activate: () => { return Promise.resolve(); }
+		},
+		workspaceConfig: {
+			get: () => {return 'value';},
+			has: () => {return true;},
+			inspect: () => {return undefined;},
+			update: () => {return Promise.reject();},
 		}
 	};
 }
@@ -85,6 +133,9 @@ describe('Main Controller', () => {
 
 	it('initialize Should install dependencies successfully', async function (): Promise<void> {
 		let testContext = createContext();
+
+		testContext.apiWrapper.setup(x => x.getExtension(TypeMoq.It.isAny())).returns(() => testContext.notebookExtension);
+		testContext.apiWrapper.setup(x => x.getConfiguration(TypeMoq.It.isAny())).returns(() => testContext.workspaceConfig);
 		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());
@@ -92,25 +143,10 @@ describe('Main Controller', () => {
 		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);
-	});
 });

extensions/machine-learning-services/src/test/packageManagement/packageManager.test.ts

@@ -11,14 +11,12 @@ 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> {
@@ -32,6 +30,18 @@ describe('Package Manager', () => {
 		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 execute the command if r 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.queryRunner.setup(x => x.isPythonInstalled(connection)).returns(() => {return Promise.resolve(false);});
+		testContext.queryRunner.setup(x => x.isRInstalled(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();
@@ -39,6 +49,7 @@ describe('Package Manager', () => {
 		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);});
+		testContext.queryRunner.setup(x => x.isRInstalled(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());
@@ -56,9 +67,9 @@ describe('Package Manager', () => {
 		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> {
+	it('installDependencies Should download sqlmlutils 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"}
@@ -66,35 +77,14 @@ describe('Package Manager', () => {
 		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);
-	});
+		testContext.httpClient.verify(x => x.download(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 
-	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> {
@@ -107,9 +97,6 @@ describe('Package Manager', () => {
 		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;
@@ -132,9 +119,6 @@ describe('Package Manager', () => {
 		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;
@@ -154,9 +138,7 @@ describe('Package Manager', () => {
 		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();
@@ -174,7 +156,7 @@ describe('Package Manager', () => {
 		should.equal(packagesInstalled, true);
 	});
 
-	it('installDependencies Should fail if install packages fails', async function (): Promise<void> {
+	it('installDependencies Should fail if download packages fails', async function (): Promise<void> {
 		let testContext = createContext();
 		let packagesInstalled = false;
 		let installedPackages = `[
@@ -183,9 +165,7 @@ describe('Package Manager', () => {
 		testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
 			operationInfo.operation(testContext.op);
 		});
-		testContext.jupyterInstallation.installPythonPackage = ()  => {
-			return Promise.resolve();
-		};
+		testContext.httpClient.setup(x => x.download(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.reject());
 		testContext.processService.setup(x => x.executeBufferedCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((command) => {
 			if (command.indexOf('pip list') > 0) {
 				return Promise.resolve(installedPackages);
@@ -207,15 +187,23 @@ describe('Package Manager', () => {
 			{ name: 'pymssql', version: '2.1.4' },
 			{ name: 'sqlmlutils', version: '' }
 		]);
+		testContext.config.setup(x => x.requiredRPackages).returns( () => [
+			{ name: 'RODBCext', repository: 'https://cran.microsoft.com' },
+			{ name: 'sqlmlutils', fileName: 'sqlmlutils_0.7.1.zip', downloadUrl: 'https://github.com/microsoft/sqlmlutils/blob/master/R/dist/sqlmlutils_0.7.1.zip?raw=true'}
+		]);
+		testContext.httpClient.setup(x => x.download(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve());
+		testContext.config.setup(x => x.pythonExecutable).returns(() => 'python');
+		testContext.config.setup(x => x.rExecutable).returns(() => 'r');
 		let packageManager = new PackageManager(
-			testContext.nbExtensionApis,
 			testContext.outputChannel,
 			'',
 			testContext.apiWrapper.object,
 			testContext.queryRunner.object,
 			testContext.processService.object,
-			testContext.config.object);
+			testContext.config.object,
+			testContext.httpClient.object);
 		packageManager.init();
+		packageManager.dependenciesInstalled = true;
 		return packageManager;
 	}
 });

extensions/machine-learning-services/src/test/packageManagement/sqlPythonPackageManageProvider.test.ts

@@ -10,11 +10,11 @@ import * as should from 'should';
 import 'mocha';
 import * as TypeMoq from 'typemoq';
 import * as constants from '../../common/constants';
-import { SqlPythonPackageManageProvider } from '../../packageManagement/sqlPackageManageProvider';
+import { SqlPythonPackageManageProvider } from '../../packageManagement/sqlPythonPackageManageProvider';
 import { createContext, TestContext } from './utils';
 import * as nbExtensionApis from '../../typings/notebookServices';
 
-describe('SQL Package Manager', () => {
+describe('SQL Python Package Manager', () => {
 	it('Should create SQL package manager successfully', async function (): Promise<void> {
 		let testContext = createContext();
 		should.doesNotThrow(() => createProvider(testContext));
@@ -59,6 +59,38 @@ describe('SQL Package Manager', () => {
 		should.deepEqual(actual, expected);
 	});
 
+	it('listPackages Should return packages sorted by name and version', async function (): Promise<void> {
+		let testContext = createContext();
+		let packages: nbExtensionApis.IPackageDetails[] = [
+			{
+				'name': 'b-name',
+				'version': '1.1.1'
+			},
+			{
+				'name': 'b-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': 'b-name',
+				'version': '1.1.1'
+			},
+			{
+				'name': 'b-name',
+				'version': '1.1.2'
+			}
+		];
+		should.deepEqual(actual, expected);
+	});
+
 	it('listPackages Should return empty packages if undefined packages returned', async function (): Promise<void> {
 		let testContext = createContext();
 
@@ -106,7 +138,7 @@ describe('SQL Package Manager', () => {
 		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[]) => {
+		testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), 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) &&
@@ -118,7 +150,7 @@ describe('SQL Package Manager', () => {
 				packagesUpdated = true;
 			}
 
-			return Promise.resolve();
+			return Promise.resolve('');
 		});
 
 		let provider = createProvider(testContext);
@@ -147,7 +179,7 @@ describe('SQL Package Manager', () => {
 		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[]) => {
+		testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), 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) &&
@@ -158,7 +190,7 @@ describe('SQL Package Manager', () => {
 				packagesUpdated = true;
 			}
 
-			return Promise.resolve();
+			return Promise.resolve('');
 		});
 
 		let provider = createProvider(testContext);
@@ -187,7 +219,7 @@ describe('SQL Package Manager', () => {
 		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[]) => {
+		testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), 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) &&
@@ -199,7 +231,7 @@ describe('SQL Package Manager', () => {
 				packagesUpdated = true;
 			}
 
-			return Promise.resolve();
+			return Promise.resolve('');
 		});
 
 		let provider = createProvider(testContext);
@@ -218,9 +250,9 @@ describe('SQL Package Manager', () => {
 		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(() => {
+		testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {
 			packagesUpdated = true;
-			return Promise.resolve();
+			return Promise.resolve('');
 		});
 
 
@@ -240,9 +272,9 @@ describe('SQL Package Manager', () => {
 		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(() => {
+		testContext.processService.setup(x => x.execScripts(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {
 			packagesUpdated = true;
-			return Promise.resolve();
+			return Promise.resolve('');
 		});
 
 
@@ -289,33 +321,16 @@ describe('SQL Package Manager', () => {
 		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': ''
+			name: 'package name',
+			versions: ['0.0.2', '0.0.1'],
+			summary: 'package 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);
+		testContext.httpClient.setup(x => x.fetch(TypeMoq.It.isAny())).returns(() => {
+			return Promise.resolve(`{"info":{"summary":"package summary"}, "releases":{"0.0.1":[{"comment_text":""}], "0.0.2":[{"comment_text":""}]}}`);
+		});
 
 		let provider = createProvider(testContext);
 		let actual = await provider.getPackageOverview('package name');
@@ -362,12 +377,13 @@ describe('SQL Package Manager', () => {
 	});
 
 	function createProvider(testContext: TestContext): SqlPythonPackageManageProvider {
+		testContext.config.setup(x => x.pythonExecutable).returns(() => 'python');
 		return new SqlPythonPackageManageProvider(
-			testContext.nbExtensionApis,
 			testContext.outputChannel,
-			'',
 			testContext.apiWrapper.object,
 			testContext.queryRunner.object,
-			testContext.processService.object);
+			testContext.processService.object,
+			testContext.config.object,
+			testContext.httpClient.object);
 	}
 });

extensions/machine-learning-services/src/test/packageManagement/sqlRPackageManageProvider.test.ts

@@ -0,0 +1,313 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { SqlRPackageManageProvider } from '../../packageManagement/sqlRPackageManageProvider';
+import { createContext, TestContext } from './utils';
+import * as nbExtensionApis from '../../typings/notebookServices';
+
+describe('SQL R 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(SqlRPackageManageProvider.ProviderId, provider.providerId);
+		should.deepEqual({ location: 'SQL', packageType: 'R' }, 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.getRPackages(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.getRPackages(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.getRPackages(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(), TypeMoq.It.isAny())).returns((path, scripts: string[]) => {
+
+			if (path && scripts.find(x => x.indexOf('install') > 0) &&
+				scripts.find(x => x.indexOf('server="serverName"') > 0) &&
+				scripts.find(x => x.indexOf('database="databaseName"') > 0) &&
+				scripts.find(x => x.indexOf('"a-name"') > 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(), TypeMoq.It.isAny())).returns((path, scripts: string[]) => {
+
+			if (path && scripts.find(x => x.indexOf('remove') > 0) &&
+				scripts.find(x => x.indexOf('server="serverName"') > 0) &&
+				scripts.find(x => x.indexOf('database="databaseName"') > 0) &&
+				scripts.find(x => x.indexOf('"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 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(), 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(), 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 r 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.isRInstalled(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 r 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.isRInstalled(TypeMoq.It.isAny())).returns(() => Promise.resolve(true));
+
+		let provider = createProvider(testContext);
+		let actual = await provider.canUseProvider();
+
+		should.deepEqual(actual, true);
+	});
+
+	it('getPackageOverview Should return package info successfully', async function (): Promise<void> {
+		let testContext = createContext();
+		let packagePreview = {
+			'name': 'a-name',
+			'versions': ['1.1.2'],
+			'summary': ''
+		};
+		let allPackages = [{
+			'name': 'a-name',
+			'version': '1.1.2'
+		}];
+		testContext.queryRunner.setup(x => x.getRAvailablePackages(TypeMoq.It.isAny())).returns(() => Promise.resolve(allPackages));
+		let provider = createProvider(testContext);
+		let actual = await provider.getPackageOverview('a-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): SqlRPackageManageProvider {
+		testContext.config.setup(x => x.rExecutable).returns(() => 'r');
+		return new SqlRPackageManageProvider(
+			testContext.outputChannel,
+			testContext.apiWrapper.object,
+			testContext.queryRunner.object,
+			testContext.processService.object,
+			testContext.config.object);
+	}
+});

extensions/machine-learning-services/src/test/packageManagement/utils.ts

@@ -7,17 +7,15 @@
 
 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';
+import { Config } from '../../configurations/config';
+import { HttpClient } from '../../common/httpClient';
 
 export interface TestContext {
-	jupyterInstallation: nbExtensionApis.IJupyterServerInstallation;
-	jupyterController: nbExtensionApis.IJupyterController;
-	nbExtensionApis: nbExtensionApis.IExtensionApi;
+
 	outputChannel: vscode.OutputChannel;
 	processService: TypeMoq.IMock<ProcessService>;
 	apiWrapper: TypeMoq.IMock<ApiWrapper>;
@@ -25,39 +23,13 @@ export interface TestContext {
 	config: TypeMoq.IMock<Config>;
 	op: azdata.BackgroundOperation;
 	getOpStatus: () => azdata.TaskStatus;
+	httpClient: TypeMoq.IMock<HttpClient>;
 }
 
 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: () => { },
@@ -71,6 +43,7 @@ export function createContext(): TestContext {
 		apiWrapper: TypeMoq.Mock.ofType(ApiWrapper),
 		queryRunner: TypeMoq.Mock.ofType(QueryRunner),
 		config: TypeMoq.Mock.ofType(Config),
+		httpClient: TypeMoq.Mock.ofType(HttpClient),
 		op: {
 			updateStatus: (status: azdata.TaskStatus) => {
 				opStatus = status;