added test for the no install case

Author: akshita31

src/InstallRuntimeDependencies.ts

@@ -6,20 +6,19 @@
 import { PlatformInformation } from './platform';
 import { PackageInstallation, LogPlatformInfo, InstallationSuccess } from './omnisharp/loggingEvents';
 import { EventStream } from './EventStream';
-import { downloadAndInstallPackages } from './packageManager/downloadAndInstallPackages';
-import { NetworkSettingsProvider } from './NetworkSettings';
 import { getRuntimeDependenciesPackages } from './tools/RuntimeDependencyPackageUtils';
 import { getAbsolutePathPackagesToInstall } from './packageManager/getAbsolutePathPackagesToInstall';
+import IInstallDependencies from './packageManager/IInstallDependencies';
 
-export async function installRuntimeDependencies(packageJSON: any, extensionPath: string, networkSettingsProvider: NetworkSettingsProvider, eventStream: EventStream, platformInfo: PlatformInformation): Promise<boolean>{
+export async function installRuntimeDependencies(packageJSON: any, extensionPath: string, installDependencies: IInstallDependencies, eventStream: EventStream, platformInfo: PlatformInformation): Promise<boolean>{
     let runTimeDependencies = getRuntimeDependenciesPackages(packageJSON);
     let packagesToInstall = await getAbsolutePathPackagesToInstall(runTimeDependencies, platformInfo, extensionPath);
     if (packagesToInstall && packagesToInstall.length > 0) {
         eventStream.post(new PackageInstallation("C# dependencies"));
         try {
             // Display platform information and RID
             eventStream.post(new LogPlatformInfo(platformInfo));
-            await downloadAndInstallPackages(packagesToInstall, networkSettingsProvider, eventStream);
+            await installDependencies(packagesToInstall);
             eventStream.post(new InstallationSuccess());
             return true;
         }

src/main.ts

@@ -27,7 +27,7 @@ import TelemetryReporter from 'vscode-extension-telemetry';
 import { addJSONProviders } from './features/json/jsonContributions';
 import { ProjectStatusBarObserver } from './observers/ProjectStatusBarObserver';
 import CSharpExtensionExports from './CSharpExtensionExports';
-import { vscodeNetworkSettingsProvider, NetworkSettingsProvider } from './NetworkSettings';
+import { vscodeNetworkSettingsProvider } from './NetworkSettings';
 import { ErrorMessageObserver } from './observers/ErrorMessageObserver';
 import OptionProvider from './observers/OptionProvider';
 import DotNetTestChannelObserver from './observers/DotnetTestChannelObserver';
@@ -38,6 +38,9 @@ import { CSharpExtensionId } from './constants/CSharpExtensionId';
 import { OpenURLObserver } from './observers/OpenURLObserver';
 import { activateRazorExtension } from './razor/razor';
 import { RazorLoggerObserver } from './observers/RazorLoggerObserver';
+import { AbsolutePathPackage } from './packageManager/AbsolutePathPackage';
+import { downloadAndInstallPackages } from './packageManager/downloadAndInstallPackages';
+import IInstallDependencies from './packageManager/IInstallDependencies';
 import { installRuntimeDependencies } from './InstallRuntimeDependencies';
 
 export async function activate(context: vscode.ExtensionContext): Promise<CSharpExtensionExports> {
@@ -116,7 +119,8 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     eventStream.subscribe(telemetryObserver.post);
 
     let networkSettingsProvider = vscodeNetworkSettingsProvider(vscode);
-    let runtimeDependenciesExist = await ensureRuntimeDependencies(extension, eventStream, platformInfo, networkSettingsProvider);
+    let installDependencies: IInstallDependencies = (dependencies: AbsolutePathPackage[]) => downloadAndInstallPackages(dependencies, networkSettingsProvider, eventStream);
+    let runtimeDependenciesExist = await ensureRuntimeDependencies(extension, eventStream, platformInfo, installDependencies);
 
     // activate language services
     let langServicePromise = OmniSharp.activate(context, extension.packageJSON, platformInfo, networkSettingsProvider, eventStream, optionProvider, extension.extensionPath);
@@ -158,7 +162,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     };
 }
 
-async function ensureRuntimeDependencies(extension: vscode.Extension<CSharpExtensionExports>, eventStream: EventStream, platformInfo: PlatformInformation, networkSettingsProvider: NetworkSettingsProvider): Promise<boolean> {
-    return installRuntimeDependencies(extension.packageJSON, extension.extensionPath, networkSettingsProvider, eventStream, platformInfo);
+async function ensureRuntimeDependencies(extension: vscode.Extension<CSharpExtensionExports>, eventStream: EventStream, platformInfo: PlatformInformation, installDependencies: IInstallDependencies): Promise<boolean> {
+    return installRuntimeDependencies(extension.packageJSON, extension.extensionPath, installDependencies, eventStream, platformInfo);
 }
 

src/packageManager/IInstallDependencies.ts

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AbsolutePathPackage } from "./AbsolutePathPackage";
+
+export default interface IInstallDependencies {
+    (packages: AbsolutePathPackage[]): Promise<void>;
+}

src/packageManager/getAbsolutePathPackagesToInstall.ts

@@ -9,6 +9,11 @@ import { getNotInstalledPackagesForPlatform } from "./PackageFilterer";
 import { Package } from "./Package";
 
 export async function getAbsolutePathPackagesToInstall(packages: Package[], platformInfo: PlatformInformation, extensionPath: string): Promise<AbsolutePathPackage[]> {
-    let absolutePathPackages = packages.map(pkg => AbsolutePathPackage.getAbsolutePathPackage(pkg, extensionPath));
-    return getNotInstalledPackagesForPlatform(absolutePathPackages, platformInfo);
+    if (packages && packages.length>0)
+    {
+        let absolutePathPackages = packages.map(pkg => AbsolutePathPackage.getAbsolutePathPackage(pkg, extensionPath));
+        return getNotInstalledPackagesForPlatform(absolutePathPackages, platformInfo);
+    }
+
+    return [];
 }

test/unitTests/InstallRuntimeDependencies.test.ts

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+import { installRuntimeDependencies } from "../../src/InstallRuntimeDependencies";
+import IInstallDependencies from "../../src/packageManager/IInstallDependencies";
+import { EventStream } from "../../src/EventStream";
+import { PlatformInformation } from "../../src/platform";
+import * as chai from "chai";
+import TestEventBus from "./testAssets/TestEventBus";
+import { AbsolutePathPackage } from "../../src/packageManager/AbsolutePathPackage";
+import { Package } from "../../src/packageManager/Package";
+
+const expect = chai.expect;
+
+suite(`${installRuntimeDependencies.name}`, () => {
+    let packageJSON = {
+        runtimeDependencies: {}
+    };
+
+    let extensionPath = "/ExtensionPath";
+    let installDependencies: IInstallDependencies;
+    let eventStream: EventStream;
+    let eventBus: TestEventBus;
+    let platformInfo = new PlatformInformation("platform1", "architecture1");
+
+    setup(() => {
+        eventStream = new EventStream(); 
+        eventBus = new TestEventBus(eventStream);
+        installDependencies = () => Promise.resolve();
+    });
+    
+    suite("When all the dependencies already exist", () => {
+        suiteSetup(() => {
+            packageJSON = {
+                runtimeDependencies: {}
+            };
+        });
+        
+        test("True is returned", async () => {
+            let installed = await installRuntimeDependencies(packageJSON, extensionPath, installDependencies, eventStream, platformInfo);
+            expect(installed).to.be.true;
+        });
+
+        test("Doesn't log anything to the eventStream", async() => {
+            let packageJSON = {
+                runtimeDependencies: {}
+            };
+
+            await installRuntimeDependencies(packageJSON, extensionPath, installDependencies, eventStream, platformInfo);
+            expect(eventBus.getEvents()).to.be.empty;
+        });
+    });
+
+    suite("When there is a dependency to install", () => {
+        let packageToInstall : Package= {
+            id:"myPackage",
+            description: "somePackage",
+            installPath: "installPath",
+            binaries: [],
+            url: "myUrl",
+            platforms: [platformInfo.platform],
+            architectures: [platformInfo.architecture]
+        };
+
+        setup(() => {
+            packageJSON = {
+                runtimeDependencies: [packageToInstall]
+            };
+        });
+
+        test("Calls installDependencies with the absolute path package and returns true after successful installation", async () => {
+            let inputPackage: AbsolutePathPackage[];
+            installDependencies = (packages) => {
+                inputPackage = packages;
+                return Promise.resolve();
+            };
+
+            let installed = await installRuntimeDependencies(packageJSON, extensionPath, installDependencies, eventStream, platformInfo);
+            expect(installed).to.be.true;
+            expect(inputPackage).to.have.length(1);
+            expect(inputPackage[0]).to.be.deep.equal(AbsolutePathPackage.getAbsolutePathPackage(packageToInstall, extensionPath));
+        });
+
+        test("Returns false when installDependencies throws exception", async () => {
+            installDependencies = () => Promise.reject("some reason");
+            let installed = await installRuntimeDependencies(packageJSON, extensionPath, installDependencies, eventStream, platformInfo);
+            expect(installed).to.be.false;
+        });
+    });
+});