@aikidosec/safe-chain 1.0.15 → 1.0.17

package/src/shell-integration/supported-shells/zsh.spec.js

@@ -0,0 +1,226 @@
+import { describe, it, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { tmpdir } from "node:os";
+import fs from "node:fs";
+import path from "path";
+import { knownAikidoTools } from "../helpers.js";
+
+describe("Zsh shell integration", () => {
+  let mockStartupFile;
+  let zsh;
+
+  beforeEach(async () => {
+    // Create temporary startup file for testing
+    mockStartupFile = path.join(tmpdir(), `test-zshrc-${Date.now()}`);
+
+    // Mock the helpers module
+    mock.module("../helpers.js", {
+      namedExports: {
+        doesExecutableExistOnSystem: () => true,
+        addLineToFile: (filePath, line) => {
+          if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, "", "utf-8");
+          }
+          fs.appendFileSync(filePath, line + "\n", "utf-8");
+        },
+        removeLinesMatchingPattern: (filePath, pattern) => {
+          if (!fs.existsSync(filePath)) return;
+          const content = fs.readFileSync(filePath, "utf-8");
+          const lines = content.split("\n");
+          const filteredLines = lines.filter((line) => !pattern.test(line));
+          fs.writeFileSync(filePath, filteredLines.join("\n"), "utf-8");
+        },
+      },
+    });
+
+    // Mock child_process execSync
+    mock.module("child_process", {
+      namedExports: {
+        execSync: () => mockStartupFile,
+      },
+    });
+
+    // Import zsh module after mocking
+    zsh = (await import("./zsh.js")).default;
+  });
+
+  afterEach(() => {
+    // Clean up test files
+    if (fs.existsSync(mockStartupFile)) {
+      fs.unlinkSync(mockStartupFile);
+    }
+
+    // Reset mocks
+    mock.reset();
+  });
+
+  describe("isInstalled", () => {
+    it("should return true when zsh is installed", () => {
+      assert.strictEqual(zsh.isInstalled(), true);
+    });
+
+    it("should call doesExecutableExistOnSystem with correct parameter", () => {
+      // Test that the method calls the helper with the right executable name
+      assert.strictEqual(zsh.isInstalled(), true);
+    });
+  });
+
+  describe("setup", () => {
+    it("should add source line for zsh initialization script", () => {
+      const result = zsh.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes(
+          "source ~/.safe-chain/scripts/init-posix.sh # Safe-chain Zsh initialization script"
+        )
+      );
+    });
+
+    it("should handle empty startup file", () => {
+      const result = zsh.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("source ~/.safe-chain/scripts/init-posix.sh"));
+    });
+  });
+
+  describe("teardown", () => {
+    it("should remove npm, npx, and yarn aliases", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "alias npm='aikido-npm'",
+        "alias npx='aikido-npx'",
+        "alias yarn='aikido-yarn'",
+        "alias ls='ls --color=auto'",
+        "alias grep='grep --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("alias npm="));
+      assert.ok(!content.includes("alias npx="));
+      assert.ok(!content.includes("alias yarn="));
+      assert.ok(content.includes("alias ls="));
+      assert.ok(content.includes("alias grep="));
+    });
+
+    it("should remove zsh initialization script source line", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "source ~/.safe-chain/scripts/init-posix.sh",
+        "alias ls='ls --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+      assert.ok(content.includes("alias ls="));
+    });
+
+    it("should handle file that doesn't exist", () => {
+      if (fs.existsSync(mockStartupFile)) {
+        fs.unlinkSync(mockStartupFile);
+      }
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+    });
+
+    it("should handle file with no relevant aliases or source lines", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "alias ls='ls --color=auto'",
+        "export PATH=$PATH:~/bin",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("alias ls="));
+      assert.ok(content.includes("export PATH="));
+    });
+  });
+
+  describe("shell properties", () => {
+    it("should have correct name", () => {
+      assert.strictEqual(zsh.name, "Zsh");
+    });
+
+    it("should expose all required methods", () => {
+      assert.ok(typeof zsh.isInstalled === "function");
+      assert.ok(typeof zsh.setup === "function");
+      assert.ok(typeof zsh.teardown === "function");
+      assert.ok(typeof zsh.name === "string");
+    });
+  });
+
+  describe("integration tests", () => {
+    it("should handle complete setup and teardown cycle", () => {
+      const tools = [
+        { tool: "npm", aikidoCommand: "aikido-npm" },
+        { tool: "yarn", aikidoCommand: "aikido-yarn" },
+      ];
+
+      // Setup
+      zsh.setup();
+      let content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("source ~/.safe-chain/scripts/init-posix.sh"));
+
+      // Teardown
+      zsh.teardown(tools);
+      content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+    });
+
+    it("should handle multiple setup calls", () => {
+      const tools = [{ tool: "npm", aikidoCommand: "aikido-npm" }];
+
+      zsh.setup(tools);
+      zsh.teardown(tools);
+      zsh.setup(tools);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      const sourceMatches = (content.match(/source.*init-posix\.sh/g) || [])
+        .length;
+      assert.strictEqual(sourceMatches, 1, "Should not duplicate source lines");
+    });
+
+    it("should handle mixed content with aliases and source lines", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "alias npm='old-npm'",
+        "source ~/.safe-chain/scripts/init-posix.sh",
+        "alias ls='ls --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      // Teardown should remove both aliases and source line
+      zsh.teardown(knownAikidoTools);
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("alias npm="));
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+      assert.ok(content.includes("alias ls="));
+    });
+  });
+});

package/src/shell-integration/teardown.js

@@ -1,9 +1,7 @@
 import chalk from "chalk";
 import { ui } from "../environment/userInteraction.js";
 import { detectShells } from "./shellDetection.js";
-import { getAliases } from "./helpers.js";
-import fs from "fs";
-import { EOL } from "os";
+import { knownAikidoTools } from "./helpers.js";
 
 export async function teardown() {
   ui.writeInformation(
@@ -27,8 +25,26 @@ export async function teardown() {
 
     let updatedCount = 0;
     for (const shell of shells) {
-      if (removeAliasesForShell(shell)) {
+      let success = false;
+      try {
+        success = shell.teardown(knownAikidoTools);
+      } catch {
+        success = false;
+      }
+
+      if (success) {
+        ui.writeInformation(
+          `${chalk.bold("- " + shell.name + ":")} ${chalk.green(
+            "Teardown successful"
+          )}`
+        );
         updatedCount++;
+      } else {
+        ui.writeError(
+          `${chalk.bold("- " + shell.name + ":")} ${chalk.red(
+            "Teardown failed"
+          )}. Please check your ${shell.name} configuration.`
+        );
       }
     }
 
@@ -43,98 +59,3 @@ export async function teardown() {
     return;
   }
 }
-
-/**
- * This function removes aliases for the given shell.
- * It reads the shell's startup file (eg ~/.bashrc, ~/.zshrc, etc.),
- * and then removes the aliases for npm, npx, and yarn commands.
- * If the aliases don't exist, it will report that they were not found.
- * If the startup file does not exist, it will report that no aliases need to be removed.
- *
- * The shell startup script is loaded by the respective shell when it starts.
- * This means that the aliases will be removed from the shell after it is restarted.
- */
-function removeAliasesForShell(shell) {
-  if (!shell.startupFile) {
-    ui.writeError(
-      `- ${chalk.bold(
-        shell.name
-      )}: no startup file found. Cannot remove aliases.`
-    );
-    return false;
-  }
-
-  if (!fs.existsSync(shell.startupFile)) {
-    ui.writeInformation(
-      `- ${chalk.bold(
-        shell.name
-      )}: startup file does not exist. No aliases to remove.`
-    );
-    return false;
-  }
-
-  const aliases = getAliases(shell.startupFile);
-  const fileContent = fs.readFileSync(shell.startupFile, "utf-8");
-  const { removedCount, notFoundCount } = removeAliasesFromFile(
-    aliases,
-    fileContent,
-    shell.startupFile
-  );
-
-  let summary = "- " + chalk.bold(shell.name) + ": ";
-
-  if (removedCount > 0) {
-    summary += chalk.green(`${removedCount} aliases were removed`);
-  }
-  if (notFoundCount > 0) {
-    if (removedCount > 0) {
-      summary += ", ";
-    }
-    summary += chalk.yellow(`${notFoundCount} aliases were not found`);
-  }
-  if (removedCount === 0 && notFoundCount === 0) {
-    summary += chalk.yellow("no aliases found to remove");
-  }
-
-  ui.writeInformation(summary);
-  return removedCount > 0;
-}
-
-/**
- * This function removes the aliases from the startup file.
- * It searches for exact matches of each alias line and removes them.
- * eg: for bash it will remove 'alias npm="aikido-npm"' for npm from ~/.bashrc
- * @returns an object with the counts of removed and not found aliases.
- */
-export function removeAliasesFromFile(aliases, fileContent, startupFilePath) {
-  let removedCount = 0;
-  let notFoundCount = 0;
-  let updatedContent = fileContent;
-
-  for (const alias of aliases) {
-    const lines = updatedContent.split(EOL);
-    let aliasLineIndex = lines.findIndex((line) => line.trim() === alias);
-
-    if (aliasLineIndex !== -1) {
-      removedCount++;
-
-      // Remove all occurrences of the alias line, in case it appears multiple times
-      while (aliasLineIndex !== -1) {
-        lines.splice(aliasLineIndex, 1);
-        aliasLineIndex = lines.findIndex((line) => line.trim() === alias);
-      }
-      updatedContent = lines.join(EOL);
-    } else {
-      notFoundCount++;
-    }
-  }
-
-  if (removedCount > 0) {
-    fs.writeFileSync(startupFilePath, updatedContent, "utf-8");
-  }
-
-  return {
-    removedCount,
-    notFoundCount,
-  };
-}

package/.github/workflows/build-and-release.yml

@@ -1,41 +0,0 @@
-name: Create Release
-
-on:
-  push:
-    tags:
-      - "*"
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "lts/*"
-          registry-url: "https://registry.npmjs.org/"
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_PUBLISH_TOKEN }}
-
-      - name: Set version number
-        id: get_version
-        run: |
-          version="${{ github.ref_name }}"
-          echo "tag=$version" >> $GITHUB_OUTPUT
-
-      - name: Set the version
-        run: npm --no-git-tag-version version ${{ steps.get_version.outputs.tag }}
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Publish to npm
-        run: |
-          echo "Publishing version ${{ steps.get_version.outputs.tag }} to NPM"
-          npm publish --access public
-        env:
-          NPM_AUTH_TOKEN: ${{ secrets.NPM_PUBLISH_TOKEN }}

package/.github/workflows/test-on-pr.yml

@@ -1,28 +0,0 @@
-name: Run Unit Tests
-
-on:
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "lts/*"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Run tests
-        run: npm test
-
-      - name: Run ESLint
-        run: npm run lint