genlayer 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 
 
+## 0.1.2 (2024-11-08)
+
+## 0.1.1 (2024-11-08)
+
 ## 0.1.0 (2024-11-08)
 
 

package/dist/index.js

@@ -39699,7 +39699,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.1.0";
+var version = "0.1.2";
 
 // src/lib/config/text.ts
 var CLI_DESCRIPTION = "GenLayer CLI is a development environment for the GenLayer ecosystem. It allows developers to interact with the protocol by creating accounts, sending transactions, and working with Intelligent Contracts by testing, debugging, and deploying them.";
@@ -40302,23 +40302,24 @@ var MissingRequirementError = class extends Error {
 };
 
 // src/lib/clients/system.ts
-var asyncExec = import_node_util5.default.promisify(import_child_process.exec);
 function checkCommand(command, toolName) {
   return __async(this, null, function* () {
-    const { stderr } = yield asyncExec(command);
+    const { stderr } = yield import_node_util5.default.promisify(import_child_process.exec)(command);
     if (stderr) {
       throw new MissingRequirementError(toolName);
     }
   });
 }
 function executeCommand(cmdsByPlatform, toolName) {
-  const runningPlatform = getPlatform();
-  const command = cmdsByPlatform[runningPlatform];
-  try {
-    return asyncExec(command);
-  } catch (error) {
-    throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
-  }
+  return __async(this, null, function* () {
+    const runningPlatform = getPlatform();
+    const command = cmdsByPlatform[runningPlatform];
+    try {
+      return yield import_node_util5.default.promisify(import_child_process.exec)(command);
+    } catch (error) {
+      throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
+    }
+  });
 }
 function getPlatform() {
   const currentPlatform = process.platform;
@@ -40333,7 +40334,7 @@ function openUrl(url) {
 function getVersion(toolName) {
   return __async(this, null, function* () {
     try {
-      const toolResponse = yield asyncExec(`${toolName} --version`);
+      const toolResponse = yield import_node_util5.default.promisify(import_child_process.exec)(`${toolName} --version`);
       if (toolResponse.stderr) {
         throw new Error(toolResponse.stderr);
       }
@@ -40354,31 +40355,29 @@ function getVersion(toolName) {
 function listDockerContainers() {
   return __async(this, null, function* () {
     try {
-      const dockerResponse = yield asyncExec("docker ps -a --format '{{.Names}}'");
+      const dockerResponse = yield import_node_util5.default.promisify(import_child_process.exec)("docker ps -a --format '{{.Names}}'");
       const dockerContainers = dockerResponse.stdout.split("\n");
       return dockerContainers;
     } catch (error) {
       throw new Error("Error listing Docker containers.");
     }
-    return [];
   });
 }
 function listDockerImages() {
   return __async(this, null, function* () {
     try {
-      const dockerResponse = yield asyncExec("docker images --format '{{.Repository}}'");
+      const dockerResponse = yield import_node_util5.default.promisify(import_child_process.exec)("docker images --format '{{.Repository}}'");
       const dockerImages = dockerResponse.stdout.split("\n");
       return dockerImages;
     } catch (error) {
       throw new Error("Error listing Docker images.");
     }
-    return [];
   });
 }
 function stopDockerContainer(containerName) {
   return __async(this, null, function* () {
     try {
-      yield asyncExec(`docker stop ${containerName}`);
+      yield import_node_util5.default.promisify(import_child_process.exec)(`docker stop ${containerName}`);
     } catch (error) {
       throw new Error(`Error stopping Docker container ${containerName}.`);
     }
@@ -40387,7 +40386,7 @@ function stopDockerContainer(containerName) {
 function removeDockerContainer(containerName) {
   return __async(this, null, function* () {
     try {
-      yield asyncExec(`docker rm ${containerName}`);
+      yield import_node_util5.default.promisify(import_child_process.exec)(`docker rm ${containerName}`);
     } catch (error) {
       throw new Error(`Error removing container ${containerName}.`);
     }
@@ -40396,7 +40395,7 @@ function removeDockerContainer(containerName) {
 function removeDockerImage(imageName) {
   return __async(this, null, function* () {
     try {
-      yield asyncExec(`docker rmi ${imageName}`);
+      yield import_node_util5.default.promisify(import_child_process.exec)(`docker rmi ${imageName}`);
     } catch (error) {
       throw new Error(`Error removing image ${imageName}.`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {

package/src/lib/clients/system.ts

@@ -4,12 +4,9 @@ import open from "open";
 
 import {RunningPlatform, AVAILABLE_PLATFORMS} from "../config/simulator";
 import {MissingRequirementError} from "../errors/missingRequirement";
-import {VersionRequiredError} from "../errors/versionRequired";
-
-const asyncExec = util.promisify(exec);
 
 export async function checkCommand(command: string, toolName: string): Promise<void> {
-  const {stderr} = await asyncExec(command);
+  const {stderr} = await util.promisify(exec)(command);
   if (stderr) {
     throw new MissingRequirementError(toolName);
   }
@@ -24,14 +21,14 @@ type ExecuteCommandByPlatformInput = {
   [key in RunningPlatform]: string;
 };
 
-export function executeCommand(
+export async function executeCommand(
   cmdsByPlatform: ExecuteCommandByPlatformInput,
   toolName?: string,
-): PromiseWithChild<ExecuteCommandResult> {
+): Promise<ExecuteCommandResult> {
   const runningPlatform = getPlatform();
   const command = cmdsByPlatform[runningPlatform];
   try {
-    return asyncExec(command);
+    return await util.promisify(exec)(command);
   } catch (error: any) {
     throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
   }
@@ -51,7 +48,7 @@ export function openUrl(url: string): Promise<ChildProcess> {
 
 export async function getVersion(toolName: string): Promise<string> {
   try {
-    const toolResponse = await asyncExec(`${toolName} --version`);
+    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
 
     if (toolResponse.stderr) {
       throw new Error(toolResponse.stderr);
@@ -74,29 +71,27 @@ export async function getVersion(toolName: string): Promise<string> {
 
 export async function listDockerContainers(): Promise<string[]> {
   try {
-    const dockerResponse = await asyncExec("docker ps -a --format '{{.Names}}'");
+    const dockerResponse = await util.promisify(exec)("docker ps -a --format '{{.Names}}'");
     const dockerContainers = dockerResponse.stdout.split("\n");
     return dockerContainers;
   } catch (error) {
     throw new Error("Error listing Docker containers.");
   }
-  return [];
 }
 
 export async function listDockerImages(): Promise<string[]> {
   try {
-    const dockerResponse = await asyncExec("docker images --format '{{.Repository}}'");
+    const dockerResponse = await util.promisify(exec)("docker images --format '{{.Repository}}'");
     const dockerImages = dockerResponse.stdout.split("\n");
     return dockerImages;
   } catch (error) {
     throw new Error("Error listing Docker images.");
   }
-  return [];
 }
 
 export async function stopDockerContainer(containerName: string): Promise<void> {
   try {
-    await asyncExec(`docker stop ${containerName}`);
+    await util.promisify(exec)(`docker stop ${containerName}`);
   } catch (error) {
     throw new Error(`Error stopping Docker container ${containerName}.`);
   }
@@ -104,7 +99,7 @@ export async function stopDockerContainer(containerName: string): Promise<void>
 
 export async function removeDockerContainer(containerName: string) {
   try {
-    await asyncExec(`docker rm ${containerName}`);
+    await util.promisify(exec)(`docker rm ${containerName}`);
   } catch (error) {
     throw new Error(`Error removing container ${containerName}.`);
   }
@@ -112,7 +107,7 @@ export async function removeDockerContainer(containerName: string) {
 
 export async function removeDockerImage(imageName: string) {
   try {
-    await asyncExec(`docker rmi ${imageName}`);
+    await util.promisify(exec)(`docker rmi ${imageName}`);
   } catch (error) {
     throw new Error(`Error removing image ${imageName}.`);
   }

package/tests/libs/jsonRpcClient.test.ts

@@ -0,0 +1,60 @@
+import { describe, beforeEach, test, expect, vi, Mock } from "vitest";
+import fetch from "node-fetch";
+import { JsonRpcClient, JsonRPCParams } from "../../src/lib/clients/jsonRpcClient";
+
+vi.mock("node-fetch", () => ({
+  default: vi.fn(),
+}));
+
+describe("JsonRpcClient - Successful and Unsuccessful Requests", () => {
+  let rpcClient: JsonRpcClient;
+  const mockServerUrl = "http://mock-server-url.com";
+
+  beforeEach(() => {
+    rpcClient = new JsonRpcClient(mockServerUrl);
+  });
+
+  test("should make a successful JSON-RPC request and return the JSON response", async () => {
+    const mockResponse = { result: "success" };
+
+    (fetch as Mock).mockResolvedValueOnce({
+      ok: true,
+      json: async () => mockResponse,
+    });
+
+    const params: JsonRPCParams = {
+      method: "testMethod",
+      params: ["param1", "param2"],
+    };
+
+    const response = await rpcClient.request(params);
+
+    expect(fetch).toHaveBeenCalledWith(mockServerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: expect.stringContaining('"method":"testMethod"'),
+    });
+    expect(response).toEqual(mockResponse);
+  });
+
+  test("should return null when the fetch response is not ok", async () => {
+    (fetch as Mock).mockResolvedValueOnce({
+      ok: false,
+      json: async () => ({ error: "Something went wrong" }),
+    });
+
+    const params: JsonRPCParams = {
+      method: "testMethod",
+      params: ["param1", "param2"],
+    };
+
+    const response = await rpcClient.request(params);
+
+    expect(response).toBeNull();
+    expect(fetch).toHaveBeenCalledWith(mockServerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: expect.stringContaining('"method":"testMethod"'),
+    });
+  });
+});

package/tests/libs/system.test.ts

@@ -0,0 +1,223 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import util from "node:util";
+import {
+  checkCommand,
+  executeCommand,
+  openUrl,
+  getVersion,
+  listDockerContainers,
+  listDockerImages,
+  stopDockerContainer,
+  removeDockerContainer,
+  removeDockerImage
+} from "../../src/lib/clients/system";
+import { MissingRequirementError } from "../../src/lib/errors/missingRequirement";
+import open from "open";
+
+vi.mock("open");
+vi.mock("util");
+
+describe("System Functions - Success Paths", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("openUrl opens URL successfully", async () => {
+    const openSpy = vi.mocked(open).mockResolvedValue({} as any);
+    const url = "https://example.com";
+    await openUrl(url);
+    expect(openSpy).toHaveBeenCalledWith(url);
+  });
+
+  test("getVersion retrieves tool version", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "git v1.2.3",
+      stderr: ""
+    }));
+    const version = await getVersion("git");
+    expect(version).toBe("1.2.3");
+  });
+
+  test("checkCommand verifies a command exists", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({ stdout: "", stderr: "" }));
+    const result = await checkCommand("node --version", "node");
+    expect(result).toBe(undefined);
+  });
+
+  test("executeCommand executes a command successfully", async () => {
+    const platformSpy = vi.spyOn(process, "platform", "get").mockReturnValue("linux");
+    vi.mocked(util.promisify).mockReturnValueOnce((param: string) => Promise.resolve({
+      stdout: param,
+      stderr: ""
+    }));
+    const result = await executeCommand({
+        linux: "echo linux",
+        win32: "echo win32",
+        darwin: "echo darwin",
+      },
+      "echo");
+    expect(result.stdout).toBe("echo linux");
+    platformSpy.mockRestore();
+  });
+
+  test("listDockerContainers retrieves a list of containers", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "container1\ncontainer2",
+      stderr: ""
+    }));
+    const containers = await listDockerContainers();
+    expect(containers).toEqual(["container1", "container2"]);
+  });
+
+  test("listDockerImages retrieves a list of images", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "image1\nimage2",
+      stderr: ""
+    }));
+    const images = await listDockerImages();
+    expect(images).toEqual(["image1", "image2"]);
+  });
+
+  test("stopDockerContainer stops a container", async () => {
+    const containerId = "container123";
+    const execMock = vi.fn().mockResolvedValue({ stdout: "", stderr: "" });
+    vi.mocked(util.promisify).mockReturnValue(execMock);
+    await stopDockerContainer(containerId);
+    expect(execMock).toHaveBeenCalledWith(`docker stop ${containerId}`);
+  });
+
+  test("removeDockerContainer removes a container", async () => {
+    const containerId = "container123";
+    const execMock = vi.fn().mockResolvedValue({ stdout: "", stderr: "" });
+    vi.mocked(util.promisify).mockReturnValue(execMock);
+    await removeDockerContainer(containerId);
+    expect(execMock).toHaveBeenCalledWith(`docker rm ${containerId}`);
+  });
+
+  test("removeDockerImage removes an image", async () => {
+    const imageId = "image123";
+    const execMock = vi.fn().mockResolvedValue({ stdout: "", stderr: "" });
+    vi.mocked(util.promisify).mockReturnValue(execMock);
+    await removeDockerImage(imageId);
+    expect(execMock).toHaveBeenCalledWith(`docker rmi ${imageId}`);
+  });
+});
+
+describe("System Functions - Error Paths", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("getVersion throws an error if the command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "",
+      stderr: "command not found"
+    }));
+    const toolName = "nonexistent";
+    await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
+  });
+
+  test("getVersion returns '' if stdout is empty", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "",
+      stderr: ""
+    }));
+    const result = await getVersion('git');
+    expect(result).toBe("");
+  });
+
+  test("getVersion throw error if stdout undefined", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stderr: ""
+    }));
+    const toolName = "nonexistent";
+    await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
+  });
+
+  test("checkCommand returns false if the command does not exist", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "",
+      stderr: "command not found"
+    }));
+    const toolName = 'nonexistent';
+    await expect(checkCommand(`${toolName} --version`, toolName)).rejects.toThrow(new MissingRequirementError(toolName));
+  });
+
+  test("executeCommand throws an error if the command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution failed")));
+    await expect(executeCommand({
+        linux: "echo hello",
+        win32: "echo hello",
+        darwin: "echo hello",
+      },
+      "echo")).rejects.toThrow("Execution failed");
+  });
+
+  test("stopDockerContainer throws an error if stopping fails", async () => {
+    const containerId = "container123";
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(stopDockerContainer(containerId)).rejects.toThrow("Error stopping Docker container container123");
+  });
+
+  test("removeDockerContainer throws an error if removal fails", async () => {
+    const containerId = "container123";
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(removeDockerContainer(containerId)).rejects.toThrow("Error removing container container123.");
+  });
+
+  test("removeDockerImage throws an error if image removal fails", async () => {
+    const imageId = "image123";
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(removeDockerImage(imageId)).rejects.toThrow("Error removing image image123.");
+  });
+
+  test("throws error when command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(listDockerContainers()).rejects.toThrow("Error listing Docker containers.");
+  });
+
+  test("throws error when command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(listDockerImages()).rejects.toThrow("Error listing Docker images.");
+  });
+
+  test("throws error when command execution fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution error.")));
+    await expect(executeCommand({
+      linux: "echo no toolname",
+      win32: "echo no toolname",
+      darwin: "echo no toolname",
+    })).rejects.toThrow(
+      "Error executing echo no toolname: Execution error."
+    );
+  });
+
+  test("throws error when command execution fails (toolname)", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution error.")));
+    await expect(executeCommand({
+        linux: "echo linux",
+        win32: "echo win32",
+        darwin: "echo darwin",
+      },
+      "echo")).rejects.toThrow(
+      "Error executing echo: Execution error."
+    );
+  });
+
+  test("throws an error for unsupported platform in executeCommand", () => {
+    const unsupportedPlatform = "unsupportedOS";
+    const originalPlatform = process.platform;
+    Object.defineProperty(process, "platform", {
+      value: unsupportedPlatform,
+    });
+    const cmdsByPlatform = {
+      linux: "echo Linux",
+      darwin: "echo macOS",
+      win32: "echo Windows",
+    };
+    expect(executeCommand(cmdsByPlatform)).rejects.toThrow(
+      `Unsupported platform: ${unsupportedPlatform}.`
+    );
+    Object.defineProperty(process, "platform", { value: originalPlatform });
+  });
+});