chore: integration test for getGGShield

Author: sevbch

src/lib/ggshield-resolver-utils.ts src/lib/get-ggshield-utils.tssrc/lib/ggshield-resolver-utils.ts renamed to src/lib/get-ggshield-utils.ts

@@ -1,14 +1,14 @@
 import * as path from "path";
-import { ExtensionContext, OutputChannel } from "vscode";
 import * as fs from "fs";
 import * as tar from "tar";
 const AdmZip = require("adm-zip");
+import { ExtensionContext, OutputChannel } from "vscode";
 
 /**
  * Get the absolute path to GGShield binary. If it doesn't exist, it will be installed.
  * @param platform The platform of the user
  * @param arch The architecture of the user
- * @param context The extension context 
+ * @param context The extension context
  * @param outputChannel The output channel to use
  * @returns The absolute path to the GGShield binary
  */
@@ -57,7 +57,7 @@ export function getGGShield(
  * Get the latest version of GGShield
  * @returns The latest version of GGShield
  */
-function getGGShieldLatestVersion(): string {
+export function getGGShieldLatestVersion(): string {
   const response = require("sync-request")(
     "GET",
     "https://api.github.com/repos/GitGuardian/ggshield/releases/latest",
@@ -74,7 +74,7 @@ function getGGShieldLatestVersion(): string {
  * @param version The version of GGShield
  * @returns The folder name of the GGShield binary
  */
-function computeGGShieldFolderName(
+export function computeGGShieldFolderName(
   platform: NodeJS.Platform,
   arch: string,
   version: string
@@ -117,7 +117,7 @@ function computeGGShieldFolderName(
  * @param ggshieldFolder The folder of the GGShield binary
  * @param version The version of GGShield
  */
-function installGGShield(
+export function installGGShield(
   platform: NodeJS.Platform,
   arch: string,
   ggshieldFolder: string,

src/lib/ggshield-configuration-utils.ts

@@ -1,7 +1,7 @@
 import { ExtensionContext, OutputChannel, workspace } from "vscode";
 import * as os from "os";
 import { GGShieldConfiguration } from "./ggshield-configuration";
-import { getGGShield } from "./ggshield-resolver-utils";
+import { getGGShield } from "./get-ggshield-utils";
 
 /**
  * Retrieve configuration from settings

src/test/suite/lib/get-ggshield-utils.test.ts

@@ -0,0 +1,301 @@
+import * as assert from "assert";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import * as tar from "tar";
+const AdmZip = require("adm-zip");
+import * as getGGShieldUtils from "../../../lib/get-ggshield-utils";
+import { ExtensionContext, window, OutputChannel } from "vscode";
+
+suite("getGGShield integration tests", () => {
+  let tempDir: string;
+  let mockContext: ExtensionContext;
+  let outputChannel: OutputChannel = window.createOutputChannel("GitGuardian");
+  const platform = process.platform;
+  const arch = process.arch;
+  const latestVersion = getGGShieldUtils.getGGShieldLatestVersion();
+  let originalLog: (message?: any, ...optionalParams: any[]) => void;
+  let output: string;
+
+  setup(() => {
+    // Create temp directory for tests
+    tempDir = fs.mkdtempSync(__dirname);
+    mockContext = {
+      extensionPath: tempDir,
+    } as ExtensionContext;
+    output = ""; // Reset captured output before each test
+    originalLog = console.log; // Store original console.log
+
+    console.log = (message: string) => {
+      output += message;
+    };
+  });
+
+  teardown(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true });
+      console.log = originalLog; // Restore original console.log
+    }
+  });
+
+  test("returns existing binary path when binary exists", () => {
+    const binaryPath: string = createFakeBinary(
+      tempDir,
+      platform,
+      arch,
+      latestVersion
+    );
+    const result = getGGShieldUtils.getGGShield(
+      platform,
+      arch,
+      mockContext,
+      outputChannel
+    );
+
+    assert.strictEqual(result, binaryPath);
+    assert(fs.existsSync(result));
+    assert(result.includes(latestVersion));
+    assert(
+      !output.includes("Updated to GGShield"),
+      "installGGShield should not be called when binary exists"
+    );
+  });
+
+  test("installs binary when it doesn't exist", () => {
+    const expectedBinaryPath: string = getGGShieldUtils.computeGGShieldPath(
+      platform,
+      arch,
+      path.join(tempDir, "ggshield-internal"),
+      latestVersion
+    );
+    assert(!fs.existsSync(expectedBinaryPath));
+
+    const result = getGGShieldUtils.getGGShield(
+      platform,
+      arch,
+      mockContext,
+      outputChannel
+    );
+
+    assert(fs.existsSync(result));
+    assert.strictEqual(result, expectedBinaryPath);
+    assert(result.includes(latestVersion));
+    assert(
+      !output.includes("Updated to GGShield"),
+      "installGGShield should be called once when binary doesn't exist"
+    );
+  });
+
+  test("updates binary when older version exists", () => {
+    const oldBinaryPath: string = createFakeBinary(
+      tempDir,
+      platform,
+      arch,
+      "1.0.0"
+    );
+    const result = getGGShieldUtils.getGGShield(
+      platform,
+      arch,
+      mockContext,
+      outputChannel
+    );
+
+    assert(fs.existsSync(result));
+    assert(result.includes(latestVersion));
+    assert(!fs.existsSync(oldBinaryPath));
+    assert(
+      !output.includes("Updated to GGShield"),
+      "installGGShield should be called once when updating binary"
+    );
+  });
+});
+
+function createFakeBinary(
+  tempDir: string,
+  platform: NodeJS.Platform,
+  arch: string,
+  version: string
+): string {
+  const ggshieldFolder: string = path.join(tempDir, "ggshield-internal");
+  const binaryName: string = platform === "win32" ? "ggshield.exe" : "ggshield";
+  const versionFolder: string = path.join(
+    ggshieldFolder,
+    `${getGGShieldUtils.computeGGShieldFolderName(platform, arch, version)}`
+  );
+  const binaryPath: string = path.join(versionFolder, binaryName);
+  fs.mkdirSync(versionFolder, { recursive: true });
+  fs.writeFileSync(binaryPath, "fake binary content");
+  return binaryPath;
+}
+
+suite("ggshield-resolver-utils", () => {
+  suite("computeGGShieldPath", () => {
+    const version = "1.0.0";
+    const ggshieldFolder = "/path/to/ggshield";
+
+    test("computes correct path for Windows", () => {
+      const result = getGGShieldUtils.computeGGShieldPath(
+        "win32",
+        "x64",
+        ggshieldFolder,
+        version
+      );
+      assert.strictEqual(
+        result,
+        path.join(
+          ggshieldFolder,
+          "ggshield-1.0.0-x86_64-pc-windows-msvc",
+          "ggshield.exe"
+        )
+      );
+    });
+
+    test("computes correct path for Linux", () => {
+      const result = getGGShieldUtils.computeGGShieldPath(
+        "linux",
+        "x64",
+        ggshieldFolder,
+        version
+      );
+      assert.strictEqual(
+        result,
+        path.join(
+          ggshieldFolder,
+          "ggshield-1.0.0-x86_64-unknown-linux-gnu",
+          "ggshield"
+        )
+      );
+    });
+
+    test("computes correct path for macOS x64", () => {
+      const result = getGGShieldUtils.computeGGShieldPath(
+        "darwin",
+        "x64",
+        ggshieldFolder,
+        version
+      );
+      assert.strictEqual(
+        result,
+        path.join(
+          ggshieldFolder,
+          "ggshield-1.0.0-x86_64-apple-darwin",
+          "ggshield"
+        )
+      );
+    });
+
+    test("computes correct path for macOS arm64", () => {
+      const result = getGGShieldUtils.computeGGShieldPath(
+        "darwin",
+        "arm64",
+        ggshieldFolder,
+        version
+      );
+      assert.strictEqual(
+        result,
+        path.join(
+          ggshieldFolder,
+          "ggshield-1.0.0-arm64-apple-darwin",
+          "ggshield"
+        )
+      );
+    });
+
+    test("throws error for unsupported platform", () => {
+      assert.throws(() => {
+        getGGShieldUtils.computeGGShieldPath(
+          "sunos",
+          "x64",
+          ggshieldFolder,
+          version
+        );
+      }, /Unsupported platform/);
+    });
+
+    test("throws error for unsupported architecture", () => {
+      assert.throws(() => {
+        getGGShieldUtils.computeGGShieldPath(
+          "darwin",
+          "mips",
+          ggshieldFolder,
+          version
+        );
+      }, /Unsupported architecture/);
+    });
+  });
+
+  suite("extractGGShieldBinary", () => {
+    const testContent = "hello world";
+    const testFileName = "test.txt";
+    let tempDir: string;
+    let tarGzPath: string;
+    let zipPath: string;
+
+    setup(() => {
+      // Create temporary directory
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ggshield-test-"));
+
+      // Create test file
+      const testFilePath = path.join(tempDir, testFileName);
+      fs.writeFileSync(testFilePath, testContent);
+
+      // Create tar.gz archive
+      tarGzPath = path.join(tempDir, "archive.tar.gz");
+      tar.create(
+        {
+          gzip: true,
+          file: tarGzPath,
+          cwd: tempDir,
+          sync: true,
+        },
+        [testFileName]
+      );
+
+      // Create zip archive
+      zipPath = path.join(tempDir, "archive.zip");
+      const zip = new AdmZip();
+      zip.addFile(testFileName, Buffer.from(testContent));
+      zip.writeZip(zipPath);
+    });
+
+    teardown(() => {
+      // Clean up temporary directory and its contents
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    test("extracts tar.gz files correctly", () => {
+      const extractDir = path.join(tempDir, "extract-tar");
+      fs.mkdirSync(extractDir);
+
+      getGGShieldUtils.extractGGShieldBinary(tarGzPath, extractDir);
+
+      const extractedContent = fs.readFileSync(
+        path.join(extractDir, testFileName),
+        "utf8"
+      );
+      assert.strictEqual(extractedContent, testContent);
+    });
+
+    test("extracts zip files correctly", () => {
+      const extractDir = path.join(tempDir, "extract-zip");
+      fs.mkdirSync(extractDir);
+
+      getGGShieldUtils.extractGGShieldBinary(zipPath, extractDir);
+
+      const extractedContent = fs.readFileSync(
+        path.join(extractDir, testFileName),
+        "utf8"
+      );
+      assert.strictEqual(extractedContent, testContent);
+    });
+
+    test("throws error for unsupported file extension", () => {
+      const rarPath = path.join(tempDir, "archive.rar");
+      fs.writeFileSync(rarPath, "unsupported file extension");
+
+      assert.throws(() => {
+        getGGShieldUtils.extractGGShieldBinary(rarPath, tempDir);
+      }, /Unsupported file extension/);
+    });
+  });
+});

src/test/suite/lib/ggshield-configuration-utils.test.ts

@@ -2,7 +2,7 @@ import * as simple from "simple-mock";
 import assert = require("assert");
 import { ExtensionContext, workspace, window } from "vscode";
 import { getConfiguration } from "../../../lib/ggshield-configuration-utils";
-import * as ggshieldResolverUtils from "../../../lib/ggshield-resolver-utils";
+import * as ggshieldResolverUtils from "../../../lib/get-ggshield-utils";
 
 suite("getConfiguration", () => {
   let getConfigurationMock: simple.Stub<Function>;