Tests for the warning message display

Author: akshita31

package.json

@@ -144,7 +144,7 @@
   "runtimeDependencies": [
     {
       "description": "OmniSharp for Windows (.NET 4.6 / x86)",
-      "url": "https://nodejs.org/api/stream.html#stream_writable_write_chunk_encoding_callback",
+      "url": "https://download.visualstudio.microsoft.com/download/pr/11655913/afaf4c0f0bee0304c8b1c55dfc190a9f/omnisharp-win-x86-1.29.1.zip",
       "fallbackUrl": "https://omnisharpdownload.blob.core.windows.net/ext/omnisharp-win-x86-1.29.1.zip",
       "installPath": ".omnisharp/1.29.1",
       "platforms": [
@@ -158,7 +158,7 @@
     },
     {
       "description": "OmniSharp for Windows (.NET 4.6 / x64)",
-      "url": "https://nodejs.org/api/stream.html#stream_writable_write_chunk_encoding_callback",
+      "url": "https://download.visualstudio.microsoft.com/download/pr/11655914/fc5dedbd95030e4015ffc24e48177255/omnisharp-win-x64-1.29.1.zip",
       "fallbackUrl": "https://omnisharpdownload.blob.core.windows.net/ext/omnisharp-win-x64-1.29.1.zip",
       "installPath": ".omnisharp/1.29.1",
       "platforms": [

src/observers/WarningMessageObserver.ts

@@ -3,14 +3,11 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as fs from 'async-file';
 import { MessageItem, vscode } from '../vscodeAdapter';
-import { BaseEvent, OmnisharpServerOnError, OmnisharpServerMsBuildProjectDiagnostics, ZipFileError } from "../omnisharp/loggingEvents";
+import { BaseEvent, OmnisharpServerOnError, OmnisharpServerMsBuildProjectDiagnostics, ArchiveError } from "../omnisharp/loggingEvents";
 import { Scheduler } from 'rxjs/Scheduler';
 import { Subject } from 'rxjs/Subject';
 import 'rxjs/add/operator/debounceTime';
-import { CreateTmpFile } from '../CreateTmpAsset';
-import * as vscode1 from 'vscode';
 
 export interface MessageItemWithCommand extends MessageItem {
     command: string;
@@ -23,16 +20,7 @@ export class WarningMessageObserver {
         this.warningMessageDebouncer = new Subject<BaseEvent>();
         this.warningMessageDebouncer.debounceTime(1500, scheduler).subscribe(async event => {
             let message = "Some projects have trouble loading. Please review the output for more details.";
-            let value: MessageItemWithCommand;
-            try {
-                value = await this.vscode.window.showWarningMessage<MessageItemWithCommand>(message, { title: "Show Output", command: 'o.showOutput' });
-                if (value) {
-                    await this.vscode.commands.executeCommand<string>(value.command);
-                }
-            }
-            catch (err) {
-                console.log(err);
-            }
+            await showWarningMessage(this.vscode, message, { title: "Show Output", command: 'o.showOutput' });
         });
     }
 
@@ -44,8 +32,8 @@ export class WarningMessageObserver {
             case OmnisharpServerMsBuildProjectDiagnostics.name:
                 this.handleOmnisharpServerMsBuildProjectDiagnostics(<OmnisharpServerMsBuildProjectDiagnostics>event);
                 break;
-            case ZipFileError.name:
-                this.handleZipFileError(<ZipFileError>event);
+            case ArchiveError.name:
+                this.handleArchiveError(<ArchiveError>event);
                 break;
         }
     }
@@ -56,26 +44,19 @@ export class WarningMessageObserver {
         }
     }
 
-    private async handleZipFileError(event: ZipFileError) {
-        let tmpFile = await CreateTmpFile();
-        let writestream = fs.createWriteStream(tmpFile.name);
-        writestream.write(event.content);
-        //once we have written to the file show a warning message to open it
-        let value: MessageItemWithCommand;
-        let message = " The downloaded file is not a zip. Please review your proxy settings or view the downloaded file below.";
-        try {
-            //let file = "C:\\Users\\akagarw\\AppData\\Local\\Temp\\package-32592bbSNWBM3SWGP";
-            let file = vscode1.Uri.file(tmpFile.name);
-            value = await this.vscode.window.showWarningMessage<MessageItemWithCommand>(message, { title: "View downloaded file", command: 'vscode.open' });
-            if (value) {
-                await this.vscode.commands.executeCommand<string>(value.command,file);
-            }
-        }
-        catch (err) {
-            console.log(err);
-        }
-        finally {
-            tmpFile.dispose();
+    private async handleArchiveError(event: ArchiveError) {
+        await showWarningMessage(this.vscode, event.message);
+    }
+}
+
+async function showWarningMessage(vscode: vscode, message: string, ...items: MessageItemWithCommand[]) {
+    try {
+        let value = await vscode.window.showWarningMessage<MessageItemWithCommand>(message, ...items);
+        if (value && value.command) {
+            await vscode.commands.executeCommand<string>(value.command);
         }
     }
+    catch (err) {
+        console.log(err);
+    }
 }

src/omnisharp/loggingEvents.ts

@@ -118,8 +118,8 @@ export class DownloadSizeObtained implements BaseEvent {
     constructor(public packageSize: number) { }
 }
 
-export class ZipFileError implements BaseEvent {
-    constructor(public content: string) { }
+export class ArchiveError implements BaseEvent {
+    constructor(public message: string) { }
 }
 
 export class DebuggerPrerequisiteFailure extends EventWithMessage { }

src/packageManager/ZipInstaller.ts renamed to src/packageManager/ArchiveInstaller.ts

@@ -8,17 +8,17 @@ import * as mkdirp from 'mkdirp';
 import * as path from 'path';
 import * as yauzl from 'yauzl';
 import { EventStream } from "../EventStream";
-import { InstallationStart, ZipFileError } from "../omnisharp/loggingEvents";
+import { InstallationStart, ArchiveError } from "../omnisharp/loggingEvents";
 import { NestedError } from '../NestedError';
 
-export async function InstallZip(buffer: Buffer, description: string, destinationInstallPath: string, binaries: string[], eventStream: EventStream): Promise<void> {
+export async function InstallArchive(buffer: Buffer, description: string, destinationInstallPath: string, binaries: string[], eventStream: EventStream): Promise<void> {
     eventStream.post(new InstallationStart(description));
 
     return new Promise<void>((resolve, reject) => {
-        yauzl.fromBuffer(buffer, { lazyEntries: true }, async (err, zipFile) => {
+        yauzl.fromBuffer(buffer, { lazyEntries: true }, (err, zipFile) => {
             if (err) {
-                eventStream.post(new ZipFileError(buffer.toString()));
-                return reject(new NestedError('Immediate zip file error', err));
+                eventStream.post(new ArchiveError("C# Extension was unable to download its dependencies. Please check your internet connection. If you use a proxy server, please visit https://aka.ms/VsCodeCsharpNetworking"));
+                return reject(new NestedError('Corrupted archive error'));
             }
 
             zipFile.readEntry();

src/packageManager/PackageManager.ts

@@ -8,7 +8,7 @@ import { Package } from './Package';
 import { PackageError } from './PackageError';
 import { NestedError } from "../NestedError";
 import { DownloadFile } from './FileDownloader';
-import { InstallZip } from './ZipInstaller';
+import { InstallArchive } from './ArchiveInstaller';
 import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from "../NetworkSettings";
 import { filterPackages } from "./PackageFilterer";
@@ -21,7 +21,7 @@ export async function DownloadAndInstallPackages(packages: Package[], provider:
         for (let pkg of filteredPackages) {
             try {
                 let buffer = await DownloadFile(pkg.description, eventStream, provider, pkg.url, pkg.fallbackUrl);
-                await InstallZip(buffer, pkg.description, pkg.installPath, pkg.binaries, eventStream);
+                await InstallArchive(buffer, pkg.description, pkg.installPath, pkg.binaries, eventStream);
             }
             catch (error) {
                 if (error instanceof NestedError) {

src/vscodeAdapter.ts

@@ -899,7 +899,7 @@ export interface vscode {
     window: {
         activeTextEditor: TextEditor | undefined;
         showInformationMessage: (message: string, ...items: string[]) => Thenable<string | undefined>;
-        showWarningMessage: <T extends MessageItem>(message: string, ...items: T[]) => Thenable<T | undefined>;       
+        showWarningMessage: <T extends MessageItem>(message: string, ...items: T[]) => Thenable<T | undefined>;
     };
     workspace: {
         getConfiguration: (section?: string, resource?: Uri) => WorkspaceConfiguration;

test/unitTests/Packages/ZipInstaller.test.ts renamed to test/unitTests/Packages/ArchiveInstaller.test.ts

@@ -8,16 +8,16 @@ import * as path from 'path';
 import * as chai from 'chai';
 import * as util from '../../../src/common';
 import { CreateTmpDir, TmpAsset } from '../../../src/CreateTmpAsset';
-import { InstallZip } from '../../../src/packageManager/ZipInstaller';
+import { InstallArchive } from '../../../src/packageManager/ArchiveInstaller';
 import { EventStream } from '../../../src/EventStream';
 import { PlatformInformation } from '../../../src/platform';
-import { BaseEvent, InstallationStart } from '../../../src/omnisharp/loggingEvents';
+import { BaseEvent, InstallationStart, ArchiveError } from '../../../src/omnisharp/loggingEvents';
 import { Files, Binaries, createTestZipAsync } from '../testAssets/CreateTestZip';
 
 chai.use(require("chai-as-promised"));
 let expect = chai.expect;
 
-suite('ZipInstaller', () => {
+suite('ArchiveInstaller', () => {
     let tmpInstallDir: TmpAsset;
     let installationPath: string;
     let testBuffer: Buffer;
@@ -38,15 +38,15 @@ suite('ZipInstaller', () => {
     });
 
     test('The folder is unzipped and all the files are present at the expected paths', async () => {
-        await InstallZip(testBuffer, fileDescription, installationPath, [], eventStream);
+        await InstallArchive(testBuffer, fileDescription, installationPath, [], eventStream);
         for (let elem of allFiles) {
             let filePath = path.join(installationPath, elem.path);
             expect(await util.fileExists(filePath)).to.be.true;
         }
     });
 
     test('The folder is unzipped and all the expected events are created', async () => {
-        await InstallZip(testBuffer, fileDescription, installationPath, [], eventStream);
+        await InstallArchive(testBuffer, fileDescription, installationPath, [], eventStream);
         let eventSequence: BaseEvent[] = [
             new InstallationStart(fileDescription)
         ];
@@ -56,7 +56,7 @@ suite('ZipInstaller', () => {
     test('The folder is unzipped and the binaries have the expected permissions(except on Windows)', async () => {
         if (!((await PlatformInformation.GetCurrent()).isWindows())) {
             let resolvedBinaryPaths = Binaries.map(binary => path.join(installationPath, binary.path));
-            await InstallZip(testBuffer, fileDescription, installationPath, resolvedBinaryPaths, eventStream);
+            await InstallArchive(testBuffer, fileDescription, installationPath, resolvedBinaryPaths, eventStream);
             for (let binaryPath of resolvedBinaryPaths) {
                 expect(await util.fileExists(binaryPath)).to.be.true;
                 let mode = (await fs.stat(binaryPath)).mode;
@@ -65,8 +65,21 @@ suite('ZipInstaller', () => {
         }
     });
 
-    test('Error is thrown when the file is not a zip', async () => {
-        expect(InstallZip(new Buffer("My file", "utf8"), "Text File", installationPath, [], eventStream)).to.be.rejected;
+    test('Error is thrown when the buffer contains an invalid archive', async () => {
+        expect(InstallArchive(new Buffer("My file", "utf8"), "Text File", installationPath, [], eventStream)).to.be.rejected;
+    });
+
+    test('Error event is created when the buffer contains an invalid archive', async () => {
+        try {
+            await InstallArchive(new Buffer("some content", "utf8"), "Text File", installationPath, [], eventStream);
+        }
+        catch{
+            let eventSequence: BaseEvent[] = [
+                new InstallationStart("Text File"),
+                new ArchiveError("C# Extension was unable to download its dependencies. Please check your internet connection. If you use a proxy server, please visit https://aka.ms/VsCodeCsharpNetworking")
+            ];
+            expect(eventBus).to.be.deep.equal(eventSequence);
+        }
     });
 
     teardown(async () => {

test/unitTests/logging/WarningMessageObserver.test.ts

@@ -6,7 +6,7 @@
 import { WarningMessageObserver } from '../../../src/observers/WarningMessageObserver';
 import { assert, use as chaiUse, expect, should } from 'chai';
 import { getFakeVsCode, getMSBuildDiagnosticsMessage, getOmnisharpMSBuildProjectDiagnosticsEvent, getOmnisharpServerOnErrorEvent } from '../testAssets/Fakes';
-import { BaseEvent } from '../../../src/omnisharp/loggingEvents';
+import { BaseEvent, ArchiveError } from '../../../src/omnisharp/loggingEvents';
 import { vscode } from '../../../src/vscodeAdapter';
 import { TestScheduler } from 'rxjs/testing/TestScheduler';
 import { Observable } from 'rxjs/Observable';
@@ -172,6 +172,15 @@ suite('WarningMessageObserver', () => {
             });
         });
     });
+
+    suite('ArchiveError', () => {
+        test('When the event is fired then a warning message is displayed', () => {
+            let event = new ArchiveError("This is an error");
+            observer.post(event);
+            expect(warningMessages.length).to.be.equal(1);
+            expect(warningMessages[0]).to.be.equal("This is an error");
+        });
+    });
 });
 
 function timeToMarble(timeinMilliseconds: number): string {