test: add test cases and config

Author: nimisha-gj

jest.config.js

@@ -0,0 +1,17 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} **/
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: "node",
+  transform: {
+    "^.+.tsx?$": ["ts-jest",{}],
+  },
+  collectCoverage: true,
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.test.ts',
+    '!src/index.ts',
+    '!**/node_modules/**',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov'],
+};

package.json

@@ -7,16 +7,20 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "lint": "eslint .",
-    "dev": "nodemon --watch src --exec ts-node src/index.ts"
+    "dev": "nodemon --watch src --exec ts-node src/index.ts",
+    "test": "jest"
   },
   "author": "Nimisha G J",
   "license": "ISC",
   "devDependencies": {
     "@eslint/js": "^9.13.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^22.7.5",
     "eslint": "^9.13.0",
     "globals": "^15.11.0",
+    "jest": "^29.7.0",
     "nodemon": "^3.1.7",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.3",
     "typescript-eslint": "^8.11.0"

src/tests/MikrotikSSHClient.test.ts

@@ -0,0 +1,33 @@
+import { MikroTikSSHClient } from '../lib/MikrotikSSHClient';
+import { executeSSHCommand } from '../utils/ssh';
+
+jest.mock('../utils/ssh');
+
+describe('MikroTikSSHClient', () => {
+  const host = '192.168.1.1';
+  const port = 22;
+  const username = 'admin';
+  const password = 'password';
+  let client: MikroTikSSHClient;
+
+  beforeEach(() => {
+    client = new MikroTikSSHClient(host, port, username, password);
+  });
+
+  it('should execute a command successfully', async () => {
+    const command = 'test command';
+    (executeSSHCommand as jest.Mock).mockResolvedValue('command output');
+
+    const result = await client.executeCommand(command);
+
+    expect(result).toBe('command output');
+    expect(executeSSHCommand).toHaveBeenCalledWith(command, host, port, username, password);
+  });
+
+  it('should throw an error when the command fails', async () => {
+    const command = 'test command';
+    (executeSSHCommand as jest.Mock).mockRejectedValue(new Error('Command failed'));
+
+    await expect(client.executeCommand(command)).rejects.toThrow('Command failed');
+  });
+});

src/tests/MikrotikWireGuardClientManager.test.ts

@@ -0,0 +1,178 @@
+import { MikroTikWireGuardClientManager } from '../lib/MikroTikWireGuardClientManager';
+import { SSHClient } from '../lib/MikrotikSSHClient';
+import { AddClientResponse, RemoveClientResponse } from '../types/responses';
+import { PeerClient } from '../types/peerClient';
+
+const mockSSHClient: SSHClient = {
+  executeCommand: jest.fn(),
+};
+
+describe('MikroTikWireGuardClientManager', () => {
+  let manager: MikroTikWireGuardClientManager;
+
+  beforeEach(() => {
+    manager = new MikroTikWireGuardClientManager(mockSSHClient);
+      jest.spyOn(manager, 'listClients'); // Ensure that listClients is mocked
+  });
+
+  it('should add a client successfully', async () => {
+    const publicKey = 'testPublicKey';
+    const comment = 'Test Comment';
+    const mockIp = '192.168.1.2/24';
+
+    // Mock the methods
+    (mockSSHClient.executeCommand as jest.Mock).mockResolvedValueOnce('output with public key');
+    (manager as any).getNextAvailableIp = jest.fn().mockResolvedValue(mockIp);
+    (manager as any).getWireGuardInterfaceInfo = jest.fn().mockResolvedValue({ publicKey: 'routerPublicKey', listenPort: 51820 });
+
+    const response: AddClientResponse = await manager.addClient(publicKey, comment);
+
+    expect(response.success).toBe(true);
+    expect(response.message).toBe('VPN client added successfully');
+    expect(response.config).toEqual({ clientAddress: mockIp, routerPublicKey: 'routerPublicKey', listenPort: 51820 });
+    expect(mockSSHClient.executeCommand).toHaveBeenCalledWith(expect.stringContaining(comment));
+  });
+
+  it('should fail to add a client and return an error message', async () => {
+    const publicKey = 'testPublicKey';
+    const comment = 'Test Comment';
+
+    (mockSSHClient.executeCommand as jest.Mock).mockRejectedValue(new Error('Command failed'));
+
+    const response: AddClientResponse = await manager.addClient(publicKey, comment);
+
+    expect(response.success).toBe(false);
+    expect(response.message).toContain('VPN client added failed:Error: Error listing VPN clients');
+  });
+
+  it('should remove a client successfully', async () => {
+    const publicKey = 'testPublicKey';
+
+    (mockSSHClient.executeCommand as jest.Mock).mockResolvedValueOnce('output');
+
+    const response: RemoveClientResponse = await manager.removeClient(publicKey);
+
+    expect(response.success).toBe(true);
+    expect(response.message).toBe('VPN client removed successfully');
+    expect(mockSSHClient.executeCommand).toHaveBeenCalledWith(expect.stringContaining(publicKey));
+  });
+
+  it('should fail to remove a client and return an error message', async () => {
+    const publicKey = 'testPublicKey';
+
+    (mockSSHClient.executeCommand as jest.Mock).mockRejectedValue(new Error('Command failed'));
+
+    const response: RemoveClientResponse = await manager.removeClient(publicKey);
+
+    expect(response.success).toBe(false);
+    expect(response.message).toContain('VPN client removal failed:Error: Command failed');
+  });
+
+  // New test cases
+
+  it('should list clients successfully', async () => {
+    const mockOutput = `
+      index interface publicKey endpoint-port allowedIp
+      ;;; Test-Comment
+      0 wg0 testPublicKey 0 192.168.1.2/24
+    `;
+
+    (mockSSHClient.executeCommand as jest.Mock).mockResolvedValueOnce(mockOutput);
+
+    const clients: PeerClient[] = await manager.listClients();
+
+    expect(clients.length).toBe(2);
+    expect(clients[1]).toEqual({
+      index: '0',
+      interface: 'wg0',
+      publicKey: 'testPublicKey',
+      allowedIp: '192.168.1.2/24',
+      comment: 'Test-Comment',
+    });
+  });
+
+  it('should throw an error when listing clients fails', async () => {
+    (mockSSHClient.executeCommand as jest.Mock).mockRejectedValue(new Error('Command failed'));
+
+    await expect(manager.listClients()).rejects.toThrow('Error listing VPN clients');
+  });
+
+  it('should parse wireguard peers correctly', () => {
+    const mockOutput = `
+      index interface publicKey endpoint-port allowedIp
+      ;;; Test-Comment
+      0 wg0 testPublicKey 0 192.168.1.2/24
+    `;
+
+    const clients = manager['parseWireGuardPeers'](mockOutput);
+
+    expect(clients.length).toBe(2);
+    expect(clients[1]).toEqual({
+      index: '0',
+      interface: 'wg0',
+      publicKey: 'testPublicKey',
+      allowedIp: '192.168.1.2/24',
+      comment: 'Test-Comment',
+    });
+  });
+
+  it('should return an empty array if there are no clients to parse', () => {
+    const mockOutput = '';
+
+    const clients = manager['parseWireGuardPeers'](mockOutput);
+
+    expect(clients.length).toBe(0);
+  });
+
+  it('should get wireguard interface info successfully', async () => {
+    const mockOutput = `
+      Flags: X - disabled; R - running
+ 0  R name="wg0" mtu=1420 listen-port=51820 private-key="routerPrivateKey" public-key="routerPublicKey"
+    `;
+
+    (mockSSHClient.executeCommand as jest.Mock).mockResolvedValueOnce(mockOutput);
+
+    const info = await manager['getWireGuardInterfaceInfo']();
+
+    expect(info).toEqual({ publicKey: 'routerPublicKey', listenPort: 51820 });
+  });
+
+  it('should throw an error if the public key is missing', async () => {
+    const mockOutput = `
+      Listen Port: 51820
+    `;
+
+    (mockSSHClient.executeCommand as jest.Mock).mockResolvedValueOnce(mockOutput);
+
+    await expect(manager['getWireGuardInterfaceInfo']()).rejects.toThrow('Failed to retrieve public-key from the WireGuard interface output');
+  });
+
+  it('should throw an error if the listen port is missing', async () => {
+    const mockOutput = `
+      Flags: X - disabled; R - running
+ 0  R name="wg0" mtu=1420 private-key="routerPrivateKey" public-key="routerPublicKey"
+    `;
+
+    (mockSSHClient.executeCommand as jest.Mock).mockResolvedValueOnce(mockOutput);
+
+    await expect(manager['getWireGuardInterfaceInfo']()).rejects.toThrow('Failed to retrieve listen-port from the WireGuard interface output');
+  });
+
+  it('should get the next available IP successfully', async () => {
+    const mockClients: PeerClient[] = [
+      { index: '0', interface: 'wg0', publicKey: 'testPublicKey', allowedIp: '192.168.1.2/24', comment: 'Test Comment' },
+      { index: '1', interface: 'wg0', publicKey: 'testPublicKey', allowedIp: '192.168.1.3/24', comment: 'Test Comment' },
+    ];
+
+    (manager.listClients as jest.Mock).mockResolvedValueOnce(mockClients);
+    const nextIp = await manager['getNextAvailableIp']();
+
+    expect(nextIp).toBe('192.168.1.4/24');
+  });
+
+  it('should throw an error when getting the next available IP if no clients are found', async () => {
+    (manager.listClients as jest.Mock).mockResolvedValueOnce([]);
+
+    await expect(manager['getNextAvailableIp']()).rejects.toThrow('No valid IP addresses found from the clients.');
+  });
+});