test: add additional unit tests for CLN & Eclair

jamaljsr · jamaljsr · commit 5cc9ab934997 · 2024-04-26T00:33:20.000-05:00
diff --git a/src/lib/lightning/clightning/clightningService.spec.ts b/src/lib/lightning/clightning/clightningService.spec.ts
@@ -1,16 +1,20 @@
 import { debug } from 'electron-log';
 import { defaultStateBalances, defaultStateInfo, getNetwork } from 'utils/tests';
-import { clightningService } from './';
 import * as clightningApi from './clightningApi';
+import { CLightningService } from './clightningService';
 import * as CLN from './types';
 
-jest.mock('electron-log');
 jest.mock('./clightningApi');
 
 const clightningApiMock = clightningApi as jest.Mocked<typeof clightningApi>;
 
 describe('CLightningService', () => {
   const node = getNetwork().nodes.lightning[1];
+  let clightningService: CLightningService;
+
+  beforeEach(() => {
+    clightningService = new CLightningService();
+  });
 
   it('should get node info', async () => {
     const infoResponse: Partial<CLN.GetInfoResponse> = {
@@ -253,11 +257,6 @@ describe('CLightningService', () => {
   });
 
   describe('subscribeChannelEvents', () => {
-    afterEach(() => {
-      // Clean up any resources or mock implementations after each test
-      jest.restoreAllMocks();
-    });
-
     it('should create a channel cache, set interval, and call checkChannels', async () => {
       jest.useFakeTimers();
       const mockCallback = jest.fn();
@@ -279,6 +278,7 @@ describe('CLightningService', () => {
       );
 
       expect(clightningService.channelCaches).toBeDefined();
+      jest.useRealTimers();
     });
 
     it('should do nothing if node has already subscribed to channel event', async () => {
@@ -288,9 +288,18 @@ describe('CLightningService', () => {
       jest.spyOn(clightningService, 'checkChannels').mockReturnValue(Promise.resolve());
 
       await clightningService.subscribeChannelEvents(node, mockCallback);
+      jest.advanceTimersByTime(30 * 1000);
+
+      expect(setInterval).toHaveBeenCalledTimes(1);
+      expect(clightningService.checkChannels).toHaveBeenCalledTimes(1);
+
+      // the second time should not call setInterval or checkChannels again
+      await clightningService.subscribeChannelEvents(node, mockCallback);
+
+      expect(setInterval).toHaveBeenCalledTimes(1);
+      expect(clightningService.checkChannels).toHaveBeenCalledTimes(1);
 
-      expect(setInterval).toHaveBeenCalledTimes(0);
-      expect(clightningService.checkChannels).toHaveBeenCalledTimes(0);
+      jest.useRealTimers();
     });
 
     it('should throw an error when the implementation is not c-lightning', async () => {
@@ -333,8 +342,8 @@ describe('CLightningService', () => {
         [node.ports.rest!]: {
           intervalId: setInterval(() => {}, 1000),
           channels: [
-            { channelID: '01ff', pending: true, status: 'Opening' },
-            { channelID: '04bb', pending: false, status: 'Open' },
+            { channelId: '01ff', status: 'Opening' },
+            { channelId: '04bb', status: 'Open' },
           ],
         },
       };
@@ -352,8 +361,8 @@ describe('CLightningService', () => {
         [node.ports.rest!]: {
           intervalId: setInterval(() => {}, 1000),
           channels: [
-            { channelID: '01ff', pending: true, status: 'Opening' },
-            { channelID: '04bb', pending: false, status: 'Open' },
+            { channelId: '01ff', status: 'Opening' },
+            { channelId: '04bb', status: 'Open' },
           ],
         },
       };
@@ -385,8 +394,8 @@ describe('CLightningService', () => {
         [node.ports.rest!]: {
           intervalId: setInterval(() => {}, 1000),
           channels: [
-            { channelID: '01ff', pending: true, status: 'Opening' },
-            { channelID: '04bb', pending: false, status: 'Open' },
+            { channelId: '01ff', status: 'Opening' },
+            { channelId: '04bb', status: 'Open' },
           ],
         },
       };
diff --git a/src/lib/lightning/clightning/clightningService.ts b/src/lib/lightning/clightning/clightningService.ts
@@ -19,7 +19,20 @@ const ChannelStateToStatus: Record<CLN.ChannelState, PLN.LightningNodeChannel['s
     CLOSED: 'Closed',
   };
 
-class CLightningService implements LightningService {
+export interface CachedChannelStatus {
+  channelId: string;
+  status: PLN.LightningNodeChannel['status'];
+}
+
+export class CLightningService implements LightningService {
+  // Cache of channel states for each node, in order to simulate channel event streaming
+  channelCaches: {
+    [nodePort: number]: {
+      intervalId: NodeJS.Timeout;
+      channels: CachedChannelStatus[];
+    };
+  } = {};
+
   async getInfo(node: LightningNode): Promise<PLN.LightningNodeInfo> {
     const info = await httpGet<CLN.GetInfoResponse>(node, 'getinfo');
     return {
@@ -201,13 +214,6 @@ class CLightningService implements LightningService {
     debug('addListenerToNode CLN on port: ', node.ports.rest);
   }
 
-  channelCaches: {
-    [nodePort: number]: {
-      intervalId: NodeJS.Timeout;
-      channels: CLN.ChannelPoll[];
-    };
-  } = {};
-
   async removeListener(node: LightningNode): Promise<void> {
     const nodePort = this.getNodePort(node);
     const cache = this.channelCaches[nodePort];
@@ -244,21 +250,20 @@ class CLightningService implements LightningService {
     const apiChannels = response.map(channel => {
       const status = ChannelStateToStatus[channel.state];
       return {
-        channelID: channel.channelId,
-        pending: status !== 'Open' && status !== 'Closed',
+        channelId: channel.channelId,
         status,
       };
     });
 
-    const cache = this.channelCaches[this.getNodePort(node)];
+    const cache = this.channelCaches[this.getNodePort(node)] || { channels: [] };
     const uniqueChannels = this.getUniqueChannels(cache.channels, apiChannels);
     uniqueChannels.forEach(channel => {
-      if (channel.pending) {
-        callback({ type: 'Pending' });
-      } else if (channel.status === 'Open') {
+      if (channel.status === 'Open') {
         callback({ type: 'Open' });
       } else if (channel.status === 'Closed') {
         callback({ type: 'Closed' });
+      } else {
+        callback({ type: 'Pending' });
       }
     });
     // edge case for empty apiChannels but cache channels is not empty
@@ -270,18 +275,16 @@ class CLightningService implements LightningService {
   };
 
   getUniqueChannels = (
-    cacheChannels: CLN.ChannelPoll[],
-    apiChannels: CLN.ChannelPoll[],
-  ): CLN.ChannelPoll[] => {
-    const uniqueChannels: CLN.ChannelPoll[] = [];
+    cacheChannels: CachedChannelStatus[],
+    apiChannels: CachedChannelStatus[],
+  ): CachedChannelStatus[] => {
+    const uniqueChannels: CachedChannelStatus[] = [];
     // Check channels in apiChannels that are not in cacheChannels
     for (const channel of apiChannels) {
       if (
         !cacheChannels.some(
           cacheCh =>
-            cacheCh.channelID === channel.channelID &&
-            cacheCh.pending === channel.pending &&
-            cacheCh.status === channel.status,
+            cacheCh.channelId === channel.channelId && cacheCh.status === channel.status,
         )
       ) {
         uniqueChannels.push(channel);
diff --git a/src/lib/lightning/clightning/types.ts b/src/lib/lightning/clightning/types.ts
@@ -132,9 +132,3 @@ export interface PayResponse {
   paymentPreimage: string;
   bolt11: string;
 }
-
-export interface ChannelPoll {
-  channelID: string;
-  pending: boolean;
-  status: string;
-}
diff --git a/src/lib/lightning/eclair/eclairApi.spec.ts b/src/lib/lightning/eclair/eclairApi.spec.ts
@@ -1,13 +1,14 @@
 import { EclairNode } from 'shared/types';
+import WebSocket from 'ws';
 import * as ipc from 'lib/ipc/ipcService';
 import { getNetwork } from 'utils/tests';
-import { httpPost, setupListener, getListener } from './eclairApi';
-import WebSocket from 'ws';
+import { getListener, httpPost, removeListener, setupListener } from './eclairApi';
 
 jest.mock('ws');
 jest.mock('lib/ipc/ipcService');
 
 const ipcMock = ipc as jest.Mocked<typeof ipc>;
+const webSocketMock = WebSocket as unknown as jest.Mock<typeof WebSocket>;
 
 describe('EclairApi', () => {
   const node = getNetwork().nodes.lightning[2] as EclairNode;
@@ -63,11 +64,14 @@ describe('EclairApi', () => {
   it('should setup a listener for the provided EclairNode', () => {
     jest.useFakeTimers();
 
-    const webSocketMock = jest
-      .spyOn(WebSocket.prototype, 'ping')
-      .mockImplementation(() => {
-        return { ping: jest.fn() };
-      });
+    const pingMock = jest.fn();
+    webSocketMock.mockImplementationOnce(
+      () =>
+        ({
+          ping: pingMock,
+          readyState: WebSocket.OPEN,
+        } as any),
+    );
 
     const listener = setupListener(node);
     expect(listener).not.toBe(null);
@@ -77,8 +81,52 @@ describe('EclairApi', () => {
     jest.advanceTimersByTime(50e3);
 
     // Verify ping is called within the interval
-    expect(
-      (webSocketMock.mock.instances[0] as unknown as WebSocket).ping,
-    ).toHaveBeenCalled();
+    expect(pingMock).toHaveBeenCalled();
+  });
+
+  it('should should not send ping on a closed socket', () => {
+    jest.useFakeTimers();
+
+    const pingMock = jest.fn();
+    webSocketMock.mockImplementationOnce(
+      () =>
+        ({
+          ping: pingMock,
+          readyState: WebSocket.CLOSED,
+        } as any),
+    );
+
+    const listener = setupListener(node);
+    expect(listener).not.toBe(null);
+    expect(listener.on).not.toBe(null);
+
+    // Fast-forward time to trigger the interval
+    jest.advanceTimersByTime(50e3);
+
+    // Verify ping is called within the interval
+    expect(pingMock).not.toHaveBeenCalled();
+  });
+
+  it('should remove a listener for the provided LightningNode', () => {
+    // make sure the listener is cached
+    const listener = getListener(node);
+    expect(listener).not.toBe(null);
+
+    removeListener(node);
+
+    // it should return a different listener for the same node after removing it
+    const listener2 = getListener(node);
+    expect(listener2).not.toBe(null);
+    expect(listener2).not.toBe(listener);
+  });
+
+  it('should do nothing when removing a listener that does not exist', () => {
+    // Use a different port to ensure the listener isn't cached
+    const otherNode = {
+      ...node,
+      ports: { ...node.ports, rest: 1234 },
+    };
+    // removing a listener that doesn't exist should not throw
+    expect(() => removeListener(otherNode)).not.toThrow();
   });
 });
diff --git a/src/lib/lightning/eclair/eclairApi.ts b/src/lib/lightning/eclair/eclairApi.ts
@@ -1,6 +1,6 @@
-import WebSocket from 'ws';
 import { ipcChannels } from 'shared';
 import { EclairNode, LightningNode } from 'shared/types';
+import WebSocket from 'ws';
 import { createIpcSender } from 'lib/ipc/ipcService';
 import { eclairCredentials } from 'utils/constants';
 import * as ELN from './types';
@@ -87,7 +87,7 @@ const listen = (options: ELN.ConfigOptions): ELN.EclairWebSocket => {
   });
   // ping every 50s to keep it alive
   setInterval(() => {
-    if (socket) {
+    if (socket.readyState === WebSocket.OPEN) {
       socket.ping();
     }
   }, 50e3);
diff --git a/src/lib/lightning/eclair/eclairService.spec.ts b/src/lib/lightning/eclair/eclairService.spec.ts
@@ -451,7 +451,7 @@ describe('EclairService', () => {
 
       const mockCallback = jest.fn();
 
-      (eclairApi.getListener as jest.Mock).mockReturnValue(mockListener);
+      jest.spyOn(eclairApi, 'getListener').mockReturnValue(mockListener);
 
       await eclairService.subscribeChannelEvents(node, mockCallback);
 
@@ -496,15 +496,11 @@ describe('EclairService', () => {
     });
 
     it('should add listener to node', async () => {
-      const mockSetupListener = jest.fn();
-      (eclairApi.setupListener as jest.Mock).mockReturnValue(mockSetupListener);
       eclairService.addListenerToNode(node);
       expect(eclairApi.setupListener).toHaveBeenCalled();
     });
 
     it('should remove Listener', async () => {
-      const mockRemoveListener = jest.fn();
-      (eclairApi.removeListener as jest.Mock).mockReturnValue(mockRemoveListener);
       eclairService.removeListener(node);
       expect(eclairApi.removeListener).toHaveBeenCalled();
     });
diff --git a/src/lib/lightning/eclair/eclairService.ts b/src/lib/lightning/eclair/eclairService.ts
@@ -1,11 +1,11 @@
 import { debug } from 'electron-log';
-import { BitcoinNode, LightningNode, OpenChannelOptions, EclairNode } from 'shared/types';
+import { BitcoinNode, EclairNode, LightningNode, OpenChannelOptions } from 'shared/types';
 import { bitcoindService } from 'lib/bitcoin';
 import { LightningService } from 'types';
 import { waitFor } from 'utils/async';
 import { toSats } from 'utils/units';
 import * as PLN from '../types';
-import { httpPost, setupListener, getListener, removeListener } from './eclairApi';
+import { getListener, httpPost, removeListener, setupListener } from './eclairApi';
 import * as ELN from './types';
 
 const ChannelStateToStatus: Record<ELN.ChannelState, PLN.LightningNodeChannel['status']> =
@@ -266,6 +266,7 @@ class EclairService implements LightningService {
     // listen for incoming channel messages
     listener?.on('message', async (data: any) => {
       const response = JSON.parse(data.toString());
+      debug('Received Eclair WebSocket message:', response);
       switch (response.type) {
         case 'channel-created':
           callback({ type: 'Pending' });
diff --git a/src/lib/lightning/lnd/lndService.ts b/src/lib/lightning/lnd/lndService.ts
@@ -195,6 +195,7 @@ class LndService implements LightningService {
     callback: (event: PLN.LightningNodeChannelEvent) => void,
   ): Promise<void> {
     const cb = (data: LND.ChannelEventUpdate) => {
+      debug('Received LND ChannelEventUpdate message:', data);
       if (data.pendingOpenChannel) {
         callback({ type: 'Pending' });
       } else if (data.activeChannel?.fundingTxidBytes) {
