hsync 0.30.1 → 0.31.0

package/test/unit/peers.test.js

@@ -0,0 +1,275 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { initPeers, setRTC } from '../../lib/peers.js';
+
+describe('peers', () => {
+  let mockHsyncClient;
+  let mockMqConn;
+
+  beforeEach(() => {
+    mockMqConn = {
+      publish: vi.fn(),
+    };
+
+    mockHsyncClient = {
+      myHostName: 'myhost.example.com',
+      webUrl: 'https://myhost.example.com',
+      peerMethods: {
+        testMethod: vi.fn(),
+      },
+      mqConn: mockMqConn,
+    };
+  });
+
+  describe('setRTC', () => {
+    it('should accept an RTC implementation', () => {
+      const mockRtc = {
+        offerPeer: vi.fn(),
+        answerPeer: vi.fn(),
+      };
+
+      // Should not throw
+      expect(() => setRTC(mockRtc)).not.toThrow();
+    });
+  });
+
+  describe('initPeers', () => {
+    it('should return peer library with required methods', () => {
+      const peerLib = initPeers(mockHsyncClient);
+
+      expect(peerLib.cachedPeers).toBeTypeOf('object');
+      expect(peerLib.getRPCPeer).toBeTypeOf('function');
+      expect(peerLib.createRPCPeer).toBeTypeOf('function');
+      expect(peerLib.createServerPeer).toBeTypeOf('function');
+    });
+
+    it('should attach methods to hsyncClient', () => {
+      initPeers(mockHsyncClient);
+
+      expect(mockHsyncClient.cachedPeers).toBeTypeOf('object');
+      expect(mockHsyncClient.getRPCPeer).toBeTypeOf('function');
+      expect(mockHsyncClient.createRPCPeer).toBeTypeOf('function');
+      expect(mockHsyncClient.createServerPeer).toBeTypeOf('function');
+    });
+
+    it('should return an EventEmitter', () => {
+      const peerLib = initPeers(mockHsyncClient);
+
+      expect(peerLib.on).toBeTypeOf('function');
+      expect(peerLib.emit).toBeTypeOf('function');
+    });
+  });
+
+  describe('createRPCPeer', () => {
+    let peerLib;
+
+    beforeEach(() => {
+      peerLib = initPeers(mockHsyncClient);
+    });
+
+    it('should throw if no hostname specified', () => {
+      expect(() => peerLib.createRPCPeer({})).toThrow('No hostname specified');
+    });
+
+    it('should throw if hostname is same as client', () => {
+      expect(() => peerLib.createRPCPeer({ hostName: 'myhost.example.com' })).toThrow(
+        'Peer must be a different host'
+      );
+    });
+
+    it('should create peer with correct hostname', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(peer.hostName).toBe('other.example.com');
+    });
+
+    it('should create peer with myAuth', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(peer.myAuth).toBeTypeOf('string');
+      expect(peer.myAuth.length).toBeGreaterThan(0);
+    });
+
+    it('should create peer with rtcEvents emitter', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(peer.rtcEvents).toBeDefined();
+      expect(peer.rtcEvents.on).toBeTypeOf('function');
+    });
+
+    it('should create peer with empty sockets map', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(peer.sockets).toEqual({});
+    });
+
+    it('should create peer with localMethods', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(peer.localMethods).toBeDefined();
+      expect(peer.localMethods.rtcSignal).toBeTypeOf('function');
+    });
+
+    it('should create peer with sendJSONMsg method', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(peer.sendJSONMsg).toBeTypeOf('function');
+    });
+
+    it('should throw when sendJSONMsg called without object', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(() => peer.sendJSONMsg('not an object')).toThrow('sendJSONMsg requires an object');
+    });
+
+    it('should throw when sendJSONMsg called without connection', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(() => peer.sendJSONMsg({ test: 'data' })).toThrow('peer not connected');
+    });
+
+    it('should create peer with connectRTC method', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      expect(peer.connectRTC).toBeTypeOf('function');
+    });
+
+    it('should use default timeout of 10000', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+
+      // Timeout is passed to rawr internally, we can verify peer was created
+      expect(peer).toBeDefined();
+    });
+
+    it('should accept custom timeout', () => {
+      const peer = peerLib.createRPCPeer({
+        hostName: 'other.example.com',
+        timeout: 5000,
+      });
+
+      expect(peer).toBeDefined();
+    });
+  });
+
+  describe('getRPCPeer', () => {
+    let peerLib;
+
+    beforeEach(() => {
+      peerLib = initPeers(mockHsyncClient);
+    });
+
+    it('should create new peer if not cached', () => {
+      const peer = peerLib.getRPCPeer({ hostName: 'new.example.com' });
+
+      expect(peer).toBeDefined();
+      expect(peer.hostName).toBe('new.example.com');
+    });
+
+    it('should return cached peer on second call', () => {
+      const peer1 = peerLib.getRPCPeer({ hostName: 'cached.example.com' });
+      const peer2 = peerLib.getRPCPeer({ hostName: 'cached.example.com' });
+
+      expect(peer1).toBe(peer2);
+    });
+
+    it('should emit peerCreated event for new peer', () => {
+      const createdHandler = vi.fn();
+      peerLib.on('peerCreated', createdHandler);
+
+      peerLib.getRPCPeer({ hostName: 'new.example.com' });
+
+      expect(createdHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not emit peerCreated for cached peer', () => {
+      const createdHandler = vi.fn();
+      peerLib.on('peerCreated', createdHandler);
+
+      peerLib.getRPCPeer({ hostName: 'cached.example.com' });
+      peerLib.getRPCPeer({ hostName: 'cached.example.com' });
+
+      expect(createdHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it('should mark peer as temporary if specified', () => {
+      const peer = peerLib.getRPCPeer({
+        hostName: 'temp.example.com',
+        temporary: true,
+      });
+
+      expect(peer.rpcTemporary).toBe(true);
+    });
+  });
+
+  describe('createServerPeer', () => {
+    let peerLib;
+
+    beforeEach(() => {
+      peerLib = initPeers(mockHsyncClient);
+    });
+
+    it('should create server peer with methods', () => {
+      const methods = {
+        testMethod: vi.fn(),
+      };
+
+      const peer = peerLib.createServerPeer(mockHsyncClient, methods);
+
+      expect(peer).toBeDefined();
+    });
+
+    it('should publish to srpc topic on send', () => {
+      const methods = {};
+      const peer = peerLib.createServerPeer(mockHsyncClient, methods);
+
+      // Access the transport to test send
+      // The peer has internal transport that calls mqConn.publish
+      // We need to trigger a method call or notification
+
+      expect(peer).toBeDefined();
+    });
+  });
+
+  describe('rtcEvents handlers', () => {
+    let peerLib;
+
+    beforeEach(() => {
+      peerLib = initPeers(mockHsyncClient);
+    });
+
+    it('should handle dcOpen event', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+      peer.rtcSend = vi.fn();
+
+      peer.rtcEvents.emit('dcOpen');
+
+      expect(peer.packAndSend).toBeTypeOf('function');
+      // Should send test packet
+      expect(peer.rtcSend).toHaveBeenCalled();
+    });
+
+    it('should handle closed event', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+      peer.dcOpen = true;
+      peer.packAndSend = vi.fn();
+      peer.sockets = {
+        'socket-1': { destroy: vi.fn() },
+      };
+
+      peer.rtcEvents.emit('closed');
+
+      expect(peer.dcOpen).toBe(false);
+      expect(peer.packAndSend).toBeUndefined();
+    });
+
+    it('should handle disconnected event', () => {
+      const peer = peerLib.createRPCPeer({ hostName: 'other.example.com' });
+      peer.dcOpen = true;
+      peer.packAndSend = vi.fn();
+
+      peer.rtcEvents.emit('disconnected');
+
+      expect(peer.dcOpen).toBe(false);
+      expect(peer.packAndSend).toBeUndefined();
+    });
+  });
+});

package/test/unit/socket-listeners.test.js

@@ -0,0 +1,319 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { initListeners, setNet } from '../../lib/socket-listeners.js';
+
+describe('socket-listeners', () => {
+  let mockNet;
+  let mockSocket;
+  let mockServer;
+  let mockHsyncClient;
+  let mockRpcPeer;
+
+  beforeEach(() => {
+    mockSocket = {
+      socketId: null,
+      write: vi.fn(),
+      end: vi.fn(),
+      on: vi.fn(),
+      connect: vi.fn((port, host, cb) => cb && cb()),
+    };
+
+    mockServer = {
+      listen: vi.fn(),
+      close: vi.fn(),
+    };
+
+    mockNet = {
+      Socket: vi.fn(() => mockSocket),
+      createServer: vi.fn((handler) => {
+        mockServer.connectionHandler = handler;
+        return mockServer;
+      }),
+    };
+
+    mockRpcPeer = {
+      hostName: 'remote.example.com',
+      rtcCon: null,
+      connectRTC: vi.fn().mockResolvedValue({}),
+      notifications: {
+        oncloseListenerSocket: vi.fn(),
+      },
+      notifiers: {
+        closeRelaySocket: vi.fn(),
+      },
+      methods: {
+        connectSocket: vi.fn().mockResolvedValue({ socketId: 'test-id' }),
+      },
+      sockets: {},
+      packAndSend: vi.fn(),
+    };
+
+    mockHsyncClient = {
+      myHostName: 'local.example.com',
+      getRPCPeer: vi.fn(() => mockRpcPeer),
+    };
+
+    setNet(mockNet);
+  });
+
+  describe('setNet', () => {
+    it('should set the net implementation', () => {
+      const customNet = { Socket: vi.fn(), createServer: vi.fn() };
+      setNet(customNet);
+      // No error means success
+    });
+  });
+
+  describe('initListeners', () => {
+    it('should return object with required methods', () => {
+      const listeners = initListeners(mockHsyncClient);
+
+      expect(listeners.addSocketListener).toBeTypeOf('function');
+      expect(listeners.getSocketListeners).toBeTypeOf('function');
+    });
+
+    it('should attach methods to hsyncClient', () => {
+      initListeners(mockHsyncClient);
+
+      expect(mockHsyncClient.socketListeners).toBeTypeOf('object');
+      expect(mockHsyncClient.addSocketListener).toBeTypeOf('function');
+      expect(mockHsyncClient.getSocketListeners).toBeTypeOf('function');
+    });
+  });
+
+  describe('addSocketListener', () => {
+    let listeners;
+
+    beforeEach(() => {
+      listeners = initListeners(mockHsyncClient);
+    });
+
+    it('should throw if no targetHost', () => {
+      expect(() => listeners.addSocketListener({ port: 3000 })).toThrow('no targetHost');
+    });
+
+    it('should throw if targetHost is same as client', () => {
+      expect(() =>
+        listeners.addSocketListener({
+          port: 3000,
+          targetHost: 'https://local.example.com',
+        })
+      ).toThrow('targetHost must be a different host');
+    });
+
+    it('should clean trailing slash from targetHost', () => {
+      const listener = listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com/',
+      });
+
+      expect(listener.targetHost).toBe('https://remote.example.com');
+    });
+
+    it('should create socket server', () => {
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      expect(mockNet.createServer).toHaveBeenCalled();
+      expect(mockServer.listen).toHaveBeenCalledWith(3000);
+    });
+
+    it('should return listener object with properties', () => {
+      const listener = listeners.addSocketListener({
+        port: 3000,
+        targetPort: 4000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      expect(listener.port).toBe(3000);
+      expect(listener.targetPort).toBe(4000);
+      expect(listener.targetHost).toBe('https://remote.example.com');
+      expect(listener.socketServer).toBe(mockServer);
+      expect(listener.end).toBeTypeOf('function');
+    });
+
+    it('should use port as targetPort if not specified', () => {
+      const listener = listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      expect(listener.targetPort).toBe(3000);
+    });
+
+    it('should get RPC peer for targetHost', () => {
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      expect(mockHsyncClient.getRPCPeer).toHaveBeenCalledWith({
+        hostName: 'https://remote.example.com',
+      });
+    });
+
+    it('should store listener by port key', () => {
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      expect(mockHsyncClient.socketListeners['p3000']).toBeDefined();
+    });
+  });
+
+  describe('getSocketListeners', () => {
+    let listeners;
+
+    beforeEach(() => {
+      listeners = initListeners(mockHsyncClient);
+    });
+
+    it('should return empty array when no listeners', () => {
+      const result = listeners.getSocketListeners();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return listener info', () => {
+      listeners.addSocketListener({
+        port: 3000,
+        targetPort: 4000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      const result = listeners.getSocketListeners();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+        targetPort: 4000,
+      });
+    });
+
+    it('should return multiple listeners', () => {
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote1.example.com',
+      });
+      listeners.addSocketListener({
+        port: 4000,
+        targetHost: 'https://remote2.example.com',
+      });
+
+      const result = listeners.getSocketListeners();
+
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('listener connection handler', () => {
+    let listeners;
+
+    beforeEach(() => {
+      listeners = initListeners(mockHsyncClient);
+    });
+
+    it('should initiate RTC connection if not connected', async () => {
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      // Simulate incoming connection
+      const incomingSocket = {
+        socketId: null,
+        on: vi.fn(),
+        end: vi.fn(),
+      };
+
+      await mockServer.connectionHandler(incomingSocket);
+
+      expect(mockRpcPeer.connectRTC).toHaveBeenCalled();
+    });
+
+    it('should not initiate RTC if already connected', async () => {
+      mockRpcPeer.rtcCon = {}; // Already connected
+
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      const incomingSocket = {
+        socketId: null,
+        on: vi.fn(),
+        end: vi.fn(),
+      };
+
+      await mockServer.connectionHandler(incomingSocket);
+
+      expect(mockRpcPeer.connectRTC).not.toHaveBeenCalled();
+    });
+
+    it('should end socket if RTC connection fails', async () => {
+      mockRpcPeer.connectRTC.mockRejectedValue(new Error('RTC failed'));
+
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      const incomingSocket = {
+        socketId: null,
+        on: vi.fn(),
+        end: vi.fn(),
+      };
+
+      await mockServer.connectionHandler(incomingSocket);
+
+      expect(incomingSocket.end).toHaveBeenCalled();
+    });
+
+    it('should assign socketId to incoming socket', async () => {
+      mockRpcPeer.rtcCon = {};
+
+      listeners.addSocketListener({
+        port: 3000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      const incomingSocket = {
+        socketId: null,
+        on: vi.fn(),
+        end: vi.fn(),
+      };
+
+      await mockServer.connectionHandler(incomingSocket);
+
+      expect(incomingSocket.socketId).toBeTypeOf('string');
+    });
+
+    it('should call connectSocket on peer', async () => {
+      mockRpcPeer.rtcCon = {};
+
+      listeners.addSocketListener({
+        port: 3000,
+        targetPort: 4000,
+        targetHost: 'https://remote.example.com',
+      });
+
+      const incomingSocket = {
+        socketId: null,
+        on: vi.fn(),
+        end: vi.fn(),
+      };
+
+      await mockServer.connectionHandler(incomingSocket);
+
+      expect(mockRpcPeer.methods.connectSocket).toHaveBeenCalledWith(
+        expect.objectContaining({
+          port: 4000,
+          hostName: 'remote.example.com',
+        })
+      );
+    });
+  });
+});

package/test/unit/socket-map.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { sockets, handleSocketPacket } from '../../lib/socket-map.js';
+
+describe('socket-map', () => {
+  beforeEach(() => {
+    // Clear sockets before each test
+    Object.keys(sockets).forEach((key) => delete sockets[key]);
+  });
+
+  describe('sockets', () => {
+    it('should be an empty object initially', () => {
+      expect(sockets).toBeDefined();
+      expect(typeof sockets).toBe('object');
+    });
+
+    it('should allow adding sockets', () => {
+      const mockSocket = { write: vi.fn() };
+      sockets['test-id'] = mockSocket;
+
+      expect(sockets['test-id']).toBe(mockSocket);
+    });
+  });
+
+  describe('handleSocketPacket', () => {
+    it('should do nothing if socket is not found', () => {
+      const packet = {
+        topic: 'socketData/unknown-id',
+        payload: Buffer.from('test'),
+      };
+
+      // Should not throw
+      expect(() => handleSocketPacket(packet)).not.toThrow();
+    });
+
+    it('should write data to socket when socketData topic is received', () => {
+      const mockSocket = { write: vi.fn() };
+      sockets['socket-123'] = mockSocket;
+
+      const payload = Buffer.from('test data');
+      const packet = {
+        topic: 'socketData/socket-123',
+        payload,
+      };
+
+      handleSocketPacket(packet);
+
+      expect(mockSocket.write).toHaveBeenCalledWith(payload);
+    });
+
+    it('should not write for non-socketData topics', () => {
+      const mockSocket = { write: vi.fn() };
+      sockets['socket-123'] = mockSocket;
+
+      const packet = {
+        topic: 'otherTopic/socket-123',
+        payload: Buffer.from('test'),
+      };
+
+      handleSocketPacket(packet);
+
+      expect(mockSocket.write).not.toHaveBeenCalled();
+    });
+  });
+});