@heyputer/shell 2.1.0

package/tests/login.test.js

@@ -0,0 +1,206 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  login, logout, getUserInfo, isAuthenticated, getAuthToken, getCurrentUserName,
+  getUsageInfo
+} from '../src/commands/auth.js';
+import chalk from 'chalk';
+import Conf from 'conf';
+import { PROJECT_NAME } from '../src/commons.js';
+import * as PuterModule from '../src/modules/PuterModule.js';
+
+// Mock console to prevent actual logging
+vi.spyOn(console, 'log').mockImplementation(() => { });
+vi.spyOn(console, 'error').mockImplementation(() => { });
+
+// Mock dependencies
+vi.mock('inquirer');
+vi.mock('chalk', () => ({
+  default: {
+    green: vi.fn(text => text),
+    red: vi.fn(text => text),
+    dim: vi.fn(text => text),
+    yellow: vi.fn(text => text),
+    cyan: vi.fn(text => text),
+  }
+}));
+vi.mock('../src/modules/PuterModule.js');
+
+// Mock ProfileModule
+const mockProfileModule = {
+  switchProfileWizard: vi.fn(),
+  getAuthToken: vi.fn(),
+  getCurrentProfile: vi.fn(),
+};
+
+vi.mock('../src/modules/ProfileModule.js', () => ({
+  getProfileModule: vi.fn(() => mockProfileModule),
+  initProfileModule: vi.fn(),
+}));
+
+// Create a mock spinner object
+const mockSpinner = {
+  start: vi.fn().mockReturnThis(),
+  succeed: vi.fn().mockReturnThis(),
+  fail: vi.fn().mockReturnThis(),
+  info: vi.fn().mockReturnThis(),
+};
+
+// Mock ora
+vi.mock('ora', () => ({
+  default: vi.fn(() => mockSpinner)
+}));
+
+// Mock Conf
+vi.mock('conf', () => {
+  return {
+    default: vi.fn().mockImplementation(() => ({
+      set: vi.fn(),
+      get: vi.fn(),
+      clear: vi.fn(),
+    })),
+  };
+});
+
+describe('auth.js', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('login', () => {
+    it('should login successfully with valid credentials', async () => {
+      await login({});
+      expect(mockProfileModule.switchProfileWizard).toHaveBeenCalled();
+    });
+
+    it('should fail login with invalid credentials', async () => {
+      mockProfileModule.switchProfileWizard.mockRejectedValue(new Error('Invalid credentials'));
+      await expect(login({})).rejects.toThrow('Invalid credentials');
+      expect(mockProfileModule.switchProfileWizard).toHaveBeenCalled();
+    });
+
+    it.skip('should handle login error', async () => {
+      // This test needs to be updated to reflect the new login flow
+    });
+  });
+
+
+  describe('logout', () => {
+    let config;
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+      config = new Conf({ projectName: PROJECT_NAME });
+    });
+
+    it.skip('should logout successfully', async () => {
+      // This test needs to be updated to reflect the new login flow
+    });
+
+    it('should handle already logged out', async () => {
+      config.get = vi.fn().mockReturnValue(null);
+      await logout();
+      expect(mockSpinner.info).toHaveBeenCalledWith(chalk.yellow('Already logged out'));
+    });
+
+    it.skip('should handle logout error', async () => {
+      // This test needs to be updated to reflect the new login flow
+    });
+
+  });
+
+
+  describe('getUserInfo', () => {
+    const mockPuter = {
+      auth: {
+        getUser: vi.fn(),
+      },
+    };
+
+    beforeEach(() => {
+      vi.spyOn(PuterModule, 'getPuter').mockReturnValue(mockPuter);
+    });
+
+    it('should fetch user info successfully', async () => {
+      mockPuter.auth.getUser.mockResolvedValue({
+        username: 'testuser',
+        uuid: 'testuuid',
+        email: 'test@puter.com',
+        email_confirmed: true,
+        is_temp: false,
+        human_readable_age: '1 day',
+        feature_flags: {},
+      });
+
+      await getUserInfo();
+
+      expect(mockPuter.auth.getUser).toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('User Information:'));
+    });
+
+    it('should handle fetch user info error', async () => {
+      mockPuter.auth.getUser.mockRejectedValue(new Error('Network error'));
+      await getUserInfo();
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Failed to get user info.'));
+    });
+  });
+
+
+  describe('Authentication', () => {
+    it('should return false if auth token does not exist', () => {
+      mockProfileModule.getAuthToken.mockReturnValue(null);
+      const result = isAuthenticated();
+      expect(result).toBe(false);
+    });
+
+    it('should return null if the auth_token is not defined', () => {
+      mockProfileModule.getAuthToken.mockReturnValue(null);
+      const result = getAuthToken();
+      expect(result).toBe(null);
+    });
+
+    it('should return the current username if it is defined', () => {
+      mockProfileModule.getCurrentProfile.mockReturnValue({ username: 'testuser' });
+      const result = getCurrentUserName();
+      expect(result).toBe('testuser');
+    });
+
+  });
+
+  describe('getUsageInfo', () => {
+    const mockPuter = {
+      auth: {
+        getMonthlyUsage: vi.fn(),
+      },
+    };
+
+    beforeEach(() => {
+      vi.spyOn(PuterModule, 'getPuter').mockReturnValue(mockPuter);
+    });
+
+    it('should fetch usage info successfully', async () => {
+      mockPuter.auth.getMonthlyUsage.mockResolvedValue({
+        allowanceInfo: {
+          monthUsageAllowance: 1000,
+          remaining: 500,
+        },
+        usage: {
+          total: 500,
+        },
+        appTotals: {},
+      });
+
+      await getUsageInfo();
+
+      expect(mockPuter.auth.getMonthlyUsage).toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Allowance Information:'));
+    });
+
+    it('should handle fetch usage info error', async () => {
+      mockPuter.auth.getMonthlyUsage.mockRejectedValue(new Error('Network error'));
+      await getUsageInfo();
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Failed to fetch usage information.'));
+    });
+  });
+
+
+});

package/tests/shell.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { execCommand, getPrompt } from '../src/executor.js';
+import { getProfileModule } from '../src/modules/ProfileModule.js';
+import readline from 'node:readline';
+
+vi.mock('../src/executor.js');
+vi.mock('../src/modules/ProfileModule.js');
+vi.mock('node:readline');
+vi.mock('conf', () => {
+  const Conf = vi.fn(() => ({
+    get: vi.fn(),
+    set: vi.fn(),
+  }));
+  return { default: Conf };
+});
+
+vi.spyOn(console, 'log').mockImplementation(() => { });
+vi.spyOn(console, 'error').mockImplementation(() => { });
+
+let updatePrompt;
+let startShell;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.clearAllMocks();
+
+  vi.mocked(getPrompt).mockReturnValue('puter@/> ');
+  vi.mocked(getProfileModule).mockReturnValue({
+    checkLogin: vi.fn(),
+  });
+
+  const mockOn = vi.fn().mockReturnThis();
+  vi.mocked(readline.createInterface).mockReturnValue({
+    setPrompt: vi.fn(),
+    prompt: vi.fn(),
+    on: mockOn,
+  });
+
+  const module = await import('../src/commands/shell.js');
+  updatePrompt = module.updatePrompt;
+  startShell = module.startShell;
+});
+
+describe('updatePrompt', () => {
+  it('should call rl.setPrompt with getPrompt result', async () => {
+    await startShell();
+    const rl = readline.createInterface.mock.results[0].value;
+    rl.setPrompt.mockClear();
+
+    updatePrompt('/test/path');
+
+    expect(rl.setPrompt).toHaveBeenCalledWith('puter@/> ');
+  });
+});
+
+describe('startShell', () => {
+  it('should call checkLogin', async () => {
+    await startShell();
+    expect(getProfileModule().checkLogin).toHaveBeenCalled();
+  });
+
+  describe('with command argument', () => {
+    let mockExit;
+
+    beforeEach(() => {
+      mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('process.exit called');
+      });
+    });
+
+    afterEach(() => {
+      mockExit.mockRestore();
+    });
+
+    it('should execute command and exit when command is provided', async () => {
+      await expect(startShell('help')).rejects.toThrow('process.exit called');
+      expect(execCommand).toHaveBeenCalledWith('help');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should not create readline interface when command is provided', async () => {
+      vi.mocked(readline.createInterface).mockClear();
+      await expect(startShell('help')).rejects.toThrow('process.exit called');
+      expect(readline.createInterface).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('without command argument (interactive mode)', () => {
+    it('should create readline interface', async () => {
+      await startShell();
+      expect(readline.createInterface).toHaveBeenCalledWith({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: null,
+      });
+    });
+
+    it('should display welcome message', async () => {
+      await startShell();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Welcome to Puter-CLI'));
+    });
+
+    it('should set prompt and call prompt()', async () => {
+      await startShell();
+      const rl = readline.createInterface.mock.results[0].value;
+      expect(rl.setPrompt).toHaveBeenCalledWith('puter@/> ');
+      expect(rl.prompt).toHaveBeenCalled();
+    });
+
+    it('should register line and close event handlers', async () => {
+      await startShell();
+      const rl = readline.createInterface.mock.results[0].value;
+      expect(rl.on).toHaveBeenCalledWith('line', expect.any(Function));
+      expect(rl.on).toHaveBeenCalledWith('close', expect.any(Function));
+    });
+  });
+
+  describe('line event handler', () => {
+    let lineHandler;
+    let rl;
+
+    beforeEach(async () => {
+      await startShell();
+      rl = readline.createInterface.mock.results[0].value;
+      lineHandler = rl.on.mock.calls.find(call => call[0] === 'line')[1];
+    });
+
+    it('should execute trimmed command', async () => {
+      await lineHandler('  ls  ');
+      expect(execCommand).toHaveBeenCalledWith('ls');
+    });
+
+    it('should not execute empty line', async () => {
+      vi.mocked(execCommand).mockClear();
+      await lineHandler('   ');
+      expect(execCommand).not.toHaveBeenCalled();
+    });
+
+    it('should call prompt after executing command', async () => {
+      rl.prompt.mockClear();
+      await lineHandler('ls');
+      expect(rl.prompt).toHaveBeenCalled();
+    });
+
+    it('should log error message when execCommand throws', async () => {
+      vi.mocked(execCommand).mockRejectedValueOnce(new Error('Command failed'));
+      await lineHandler('badcmd');
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Command failed'));
+    });
+
+    it('should still call prompt after error', async () => {
+      vi.mocked(execCommand).mockRejectedValueOnce(new Error('Command failed'));
+      rl.prompt.mockClear();
+      await lineHandler('badcmd');
+      expect(rl.prompt).toHaveBeenCalled();
+    });
+  });
+
+  describe('close event handler', () => {
+    let closeHandler;
+    let mockExit;
+
+    beforeEach(async () => {
+      mockExit = vi.spyOn(process, 'exit').mockImplementation(() => { });
+      await startShell();
+      const rl = readline.createInterface.mock.results[0].value;
+      closeHandler = rl.on.mock.calls.find(call => call[0] === 'close')[1];
+    });
+
+    afterEach(() => {
+      mockExit.mockRestore();
+    });
+
+    it('should display goodbye message', () => {
+      closeHandler();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Goodbye'));
+    });
+
+    it('should exit with code 0', () => {
+      closeHandler();
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+  });
+});

package/tests/sites.test.js

@@ -0,0 +1,67 @@
+import { describe, vi, expect, it } from "vitest";
+import { createSite, deleteSite, infoSite, listSites } from "../src/commands/sites";
+import { createSubdomain, deleteSubdomain, getSubdomains } from "../src/commands/subdomains";
+import { getPuter } from "../src/modules/PuterModule.js";
+import { getCurrentDirectory } from "../src/commands/auth.js";
+
+vi.mock("../src/commands/subdomains")
+vi.mock("../src/modules/PuterModule")
+vi.mock('../src/commands/auth.js');
+
+vi.spyOn(console, "log").mockImplementation(() => { });
+
+describe("listSites", () => {
+  it("should list sites successfully", async () => {
+    vi.mocked(getSubdomains).mockResolvedValue([{
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    }])
+    await listSites();
+    expect(getSubdomains).toHaveBeenCalled();
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Total Sites: 1"))
+  })
+})
+
+describe("infoSite", () => {
+  it("should get site info successfully", async () => {
+    const mockHostingGet = vi.fn().mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    });
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        get: mockHostingGet
+      }
+    })
+
+    await infoSite(["hehe.puter.site"])
+    expect(getPuter).toHaveBeenCalled();
+    expect(mockHostingGet).toHaveBeenCalled();
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("hehe.puter.site"))
+  })
+})
+
+describe("deleteSite", () => {
+  it("should delete site successfully", async () => {
+    vi.mocked(deleteSubdomain)
+    const result = await deleteSite(["hehe.puter.site"]);
+    expect(result).toBe(true);
+  })
+})
+
+describe("createSite", () => {
+  it("should create site successfully", async () => {
+    vi.mocked(createSubdomain).mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    })
+    vi.mocked(getCurrentDirectory).mockReturnValue('/testuser');
+    const result = await createSite(["hehe hehe --subdomain=hehe"]);
+    expect(result).toMatchObject({
+      subdomain: "hehe.puter.site"
+    })
+  })
+})

package/tests/subdomains.test.js

@@ -0,0 +1,90 @@
+import { vi } from "vitest";
+import { it } from "vitest";
+import { describe } from "vitest";
+import { createSubdomain, deleteSubdomain, getSubdomains, updateSubdomain } from "../src/commands/subdomains";
+import { expect } from "vitest";
+import { getPuter } from "../src/modules/PuterModule";
+
+vi.mock("../src/modules/PuterModule")
+vi.mock("conf", () => {
+  const Conf = vi.fn(() => ({
+    get: vi.fn(),
+    set: vi.fn(),
+    clear: vi.fn(),
+  }));
+  return { default: Conf };
+});
+
+vi.spyOn(console, "log").mockImplementation(() => { });
+
+describe("getSubdomains", () => {
+  it("should get subdomains successfully", async () => {
+    const mockHostingList = vi.fn().mockResolvedValue([{
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    }]);
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        list: mockHostingList
+      }
+    })
+    const result = await getSubdomains();
+    expect(getPuter).toHaveBeenCalled();
+    expect(result).toHaveLength(1)
+  })
+})
+
+describe("deleteSubdomain", () => {
+  it("should delete subdomain successfully", async () => {
+    const mockHostingDelete = vi.fn().mockResolvedValue(true);
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        delete: mockHostingDelete
+      }
+    })
+    const result = await deleteSubdomain(["hehe.puter.site"]);
+    expect(result).toBe(true);
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Subdomain deleted successfully"));
+  })
+})
+
+describe("createSubdomain", () => {
+  it("should create subdomain successfully", async () => {
+    const mockHostingCreate = vi.fn().mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    });
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        create: mockHostingCreate
+      }
+    })
+    const result = await createSubdomain("hehe", "/mydir")
+    expect(result).toMatchObject({
+      subdomain: "hehe.puter.site"
+    })
+  })
+})
+
+describe("updateSubdomain", () => {
+  it("should update subdomain successfully", async () => {
+    const mockHostingUpdate = vi.fn().mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/newdir" },
+    });
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        update: mockHostingUpdate
+      }
+    })
+    const result = await updateSubdomain("hehe", "/newdir")
+    expect(result).toMatchObject({
+      root_dir: {
+        path: "/newdir"
+      }
+    })
+  })
+})