added unit tests for JDK Downloader view

Author: Achal1607

vscode/.nycrc.json

@@ -1,15 +1,21 @@
 {
     "extends": "@istanbuljs/nyc-config-typescript",
-    "reporter":[
+    "reporter": [
         "text",
         "html",
         "text-summary",
         "cobertura"
     ],
-    "all": true,
-    "cache": false,
+    "all": false,
     "include": [
-        "src/**/*.ts", "out/**/*.js"
+        "src/**/*.ts",
+        "out/**/*.js"
     ],
-    "exclude": [ "src/test/**/*.ts", "out/test/**/*.js"]
+    "exclude": [
+        "src/test/**/*.ts",
+        "out/test/**/*.js",
+        "out/utils.js",
+        "out/logger.js",
+        "out/constants.js"
+    ]
 }

vscode/src/test/unit/mocks/vscode/namespaces/window.ts

@@ -9,6 +9,7 @@ export const mockWindowNamespace = (mockedVSCode: Partial<VSCode>) => {
     mockedVSCode.window = instance(mockedWindow);
     mockCreateWebViewPanel();
     mockCreateOutputChannel();
+    mockMessageView();
 }
 
 const mockCreateWebViewPanel = () => {
@@ -27,3 +28,9 @@ const mockCreateOutputChannel = () => {
         anyString()
     )).thenReturn(instance(mockedOutputChannel));
 } 
+
+const mockMessageView = () => {
+    when(mockedWindow.showErrorMessage(anyString())).thenReturn(Promise.resolve(anyString()));
+    when(mockedWindow.showInformationMessage(anyString())).thenReturn(Promise.resolve(undefined));
+    when(mockedWindow.showWarningMessage(anyString())).thenReturn(Promise.resolve(undefined));
+}

vscode/src/test/unit/testUtils.ts

@@ -0,0 +1,44 @@
+import { LOGGER } from "../../logger";
+
+export const getOsType = (): string => {
+    switch (process.platform) {
+        case "linux":
+            return "linux";
+        case "darwin":
+            return "macOS";
+        default:
+            return "windows";
+    }
+}
+
+export const getMachineArch = (): string => {
+    switch (process.arch) {
+        case "arm64":
+            return "aarch64";
+        default:
+            return "x64";
+    }
+}
+
+export const getHtmlTagContent = (html: string, tagName: string): string => {
+    const regex = new RegExp(`<${tagName}[^>]*>(.*?)<\/${tagName}>`, 'is');
+    const match = html.match(regex);
+    return match?.[1]?.trim() || '';
+}
+
+export const checkTagContentNotEmpty = (html: string, tagName: string): boolean => {
+    const content = getHtmlTagContent(html, tagName);
+    return content.length !== 0;
+}
+
+export const enableMockedLoggers = (sandbox: sinon.SinonSandbox) => {
+    sandbox.stub(LOGGER, 'log').callsFake((message) => {
+        console.log(message);
+      });
+      sandbox.stub(LOGGER, 'error').callsFake((message) => {
+        console.error(message);
+      });
+      sandbox.stub(LOGGER, 'warn').callsFake((message) => {
+        console.warn(message);
+      });
+}

vscode/src/test/unit/webviews/jdkDownloader/view.unit.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, beforeEach, afterEach } from 'mocha';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { WebviewPanel, window } from 'vscode';
+import { JdkDownloaderView } from '../../../../webviews/jdkDownloader/view';
+import { checkTagContentNotEmpty, enableMockedLoggers, getMachineArch, getOsType } from '../../testUtils';
+
+describe('JDK Downloader view tests', () => {
+  let jdkDownloaderView: JdkDownloaderView;
+  const sandbox = sinon.createSandbox();
+
+  beforeEach(() => {
+    jdkDownloaderView = new JdkDownloaderView();
+    if (process.env.ENABLE_CONSOLE_LOG) {
+      enableMockedLoggers(sandbox);
+    }
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('JDK Downloader createView tests', () => {
+    let onDidReceiveMessageStub: sinon.SinonStub;
+    let createWebviewPanelStub: sinon.SinonStub;
+    let webviewPanel: WebviewPanel;
+
+    beforeEach(() => {
+      createWebviewPanelStub = sandbox.stub(window, 'createWebviewPanel');
+      onDidReceiveMessageStub = sandbox.stub();
+
+      webviewPanel = {
+        webview: {
+          html: '',
+          onDidReceiveMessage: onDidReceiveMessageStub
+        },
+        dispose: sandbox.stub()
+      } as unknown as WebviewPanel;
+
+      createWebviewPanelStub.returns(webviewPanel);
+
+      jdkDownloaderView.createView();
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    describe("Webview creation tests", () => {
+      it("should create a webview panel", () => {
+        expect(createWebviewPanelStub.calledOnce).to.be.true;
+      });
+
+      it("should check arguments while creating webview panel", () => {
+        const [, title, , options] = createWebviewPanelStub.firstCall.args;
+        expect(title).to.be.a('string').and.not.to.be.empty;
+        expect(options).to.deep.include({ enableScripts: true });
+      });
+    });
+
+    describe("Default dropdown options tests", () => {
+      it("should detect correct OS type", () => {
+        const actualOsType = (jdkDownloaderView as any).osType;
+        const expectedOs = getOsType();
+
+        expect(actualOsType).equals(expectedOs);
+      });
+
+      it("should detect correct machine architecture type", () => {
+        const actualMachineArch = (jdkDownloaderView as any).machineArch;
+        const expectedMachineArch = getMachineArch();
+
+        expect(actualMachineArch).equals(expectedMachineArch);
+      });
+    });
+
+    describe("Webview HTML tests", () => {
+      let jdkDownloaderHtml: string;
+      beforeEach(() => {
+        jdkDownloaderHtml = webviewPanel.webview.html;
+      });
+
+      it("should set the webview HTML", () => {
+        expect(jdkDownloaderHtml).to.be.a('string').and.not.to.be.empty;
+      });
+
+      it("should check HTML has all the high level tags", () => {
+        expect(jdkDownloaderHtml).to.include('<!DOCTYPE html>');
+        expect(jdkDownloaderHtml).to.include('<head>');
+        expect(jdkDownloaderHtml).to.include('<body>');
+        expect(jdkDownloaderHtml).to.include('<script>');
+        expect(jdkDownloaderHtml).to.include('<style>');
+      });
+
+      it("should check important html tags are not empty", () => {
+        expect(checkTagContentNotEmpty(jdkDownloaderHtml, 'body')).to.be.true;
+        expect(checkTagContentNotEmpty(jdkDownloaderHtml, 'head')).to.be.true;
+        expect(checkTagContentNotEmpty(jdkDownloaderHtml, 'script')).to.be.true;
+        expect(checkTagContentNotEmpty(jdkDownloaderHtml, 'style')).to.be.true;
+        expect(checkTagContentNotEmpty(jdkDownloaderHtml, 'title')).to.be.true;
+      });
+
+      it("should check if correct default OS type is chosen on the options", () => {
+        const expectedOs = getOsType();
+        const osOptionRegex = new RegExp(`<option value="${expectedOs}"[^>]*selected[^>]*>`);
+        expect(jdkDownloaderHtml).to.match(osOptionRegex);
+      });
+
+      it("should check if correct default machine architecture is chosen on the options", () => {
+        const expectedArch = getMachineArch();
+        const archOptionRegex = new RegExp(`<option value="${expectedArch}"[^>]*selected[^>]*>`);
+        expect(jdkDownloaderHtml).to.match(archOptionRegex);
+      });
+    });
+
+    it("should attach a message listener to the webview", () => {
+      expect(onDidReceiveMessageStub.calledOnce).to.be.true;
+      const listener = onDidReceiveMessageStub.firstCall.args[0];
+      expect(listener).to.be.a('function');
+    });
+
+  });
+
+  it("should dispose the webview", () => {
+    const disposeStub = sandbox.stub();
+    (jdkDownloaderView as any).jdkDownloaderWebView = { dispose: disposeStub };
+
+    jdkDownloaderView.disposeView();
+
+    expect(disposeStub.calledOnce).to.be.true;
+  });
+
+  it("should handle errors when creating view", () => {
+    const errorMessage = "Test error";
+    sandbox.stub(window, 'createWebviewPanel').throws(new Error(errorMessage));
+    const showErrorMessageStub = sandbox.stub(window, 'showErrorMessage');
+    jdkDownloaderView.createView();
+
+    expect(showErrorMessageStub.calledOnce).to.be.true;
+  });
+});

vscode/src/test/unit/webviews/jdkDownloaderAction.unit.test.ts

@@ -14,7 +14,7 @@
   limitations under the License.
 */
 
-import { commands, OpenDialogOptions, OutputChannel, window, workspace } from "vscode";
+import { commands, OpenDialogOptions, window, workspace } from "vscode";
 import { JdkDownloaderView } from "./view";
 import { jdkDownloaderConstants } from "../../constants";
 import * as path from 'path';