airdcpp-apisocket 3.0.0-beta.1 → 3.0.0-beta.11

package/src/tests/Socket.test.ts

@@ -1,7 +1,8 @@
 import { 
-  AUTH_RESPONSE, CONNECT_PARAMS, 
-  getConnectedSocket, getMockServer, getSocket, waitForExpect
-} from './helpers.js';
+  DEFAULT_AUTH_RESPONSE, DEFAULT_CONNECT_CREDENTIALS, 
+  getConnectedSocket as getOriginalConnectedSocket, getMockServer as getOriginalMockServer, getSocket as getOriginalSocket,
+  MockConnectedSocketOptions,
+} from './mocks';
 
 import ApiConstants from '../ApiConstants.js';
 
@@ -9,23 +10,23 @@ import { HookCallback, HookSubscriberInfo, SubscriptionRemoveHandler } from '../
 import { IncomingSubscriptionEvent } from '../types/api_internal.js';
 
 import { jest } from '@jest/globals';
-
-let server: ReturnType<typeof getMockServer>;
+import { defusedPromise, getMockConsole, waitForExpect } from './test-utils.js';
 
 const dummyfn = () => {
   // ..
 };
 
-const useFakeTimers = () => {
-  // Mocking performance would cause an error with Node 19, can be removed when using
-  // the latest version of Jest
-  jest.useFakeTimers({doNotFake: ['performance']});
-};
 
 // tslint:disable:no-empty
 describe('socket', () => {
+  let server: ReturnType<typeof getOriginalMockServer>;
+  let mockConsole: ReturnType<typeof getMockConsole>;
+  
   beforeEach(() => {
-    server = getMockServer();
+    mockConsole = getMockConsole();
+    server = getOriginalMockServer({
+      mockF: jest,
+    });
   });
 
   afterEach(() => {
@@ -33,17 +34,34 @@ describe('socket', () => {
     jest.useRealTimers();
   });
 
+  const getDefaultSocketOptions = () => ({
+    ...DEFAULT_CONNECT_CREDENTIALS,
+    logOutput: mockConsole,
+  });
+
+  const getMockSocket = () => {
+    return getOriginalSocket(getDefaultSocketOptions());
+  }
+
+  
+  const getConnectedMockSocket = (options?: Partial<MockConnectedSocketOptions>) => {
+    return getOriginalConnectedSocket(server, {
+      socketOptions: getDefaultSocketOptions(),
+      ...options,
+    });
+  }
+
   describe('auth', () => {
     test('should handle valid credentials', async () => {
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, AUTH_RESPONSE);
+      server.addRequestHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
       const connectedCallback = jest.fn();
 
-      const { socket, mockConsole } = getSocket();
+      const { socket } = getMockSocket();
       socket.onConnected = connectedCallback;
       const response = await socket.connect();
 
-      expect(connectedCallback).toHaveBeenCalledWith(AUTH_RESPONSE);
-      expect(response).toEqual(AUTH_RESPONSE);
+      expect(connectedCallback).toHaveBeenCalledWith(DEFAULT_AUTH_RESPONSE);
+      expect(response).toEqual(DEFAULT_AUTH_RESPONSE);
       expect(socket.isConnected()).toEqual(true);
 
       expect(mockConsole.warn.mock.calls.length).toBe(0);
@@ -54,15 +72,32 @@ describe('socket', () => {
     });
 
     test('should handle valid refresh token', async () => {
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, AUTH_RESPONSE);
+      const onAuth = jest.fn();
+      server.addRequestHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE, onAuth);
       const connectedCallback = jest.fn();
 
-      const { socket, mockConsole } = getSocket();
+      const { socket } = getMockSocket();
       socket.onConnected = connectedCallback;
       const response = await socket.connectRefreshToken('refresh token');
 
-      expect(connectedCallback).toHaveBeenCalledWith(AUTH_RESPONSE);
-      expect(response).toEqual(AUTH_RESPONSE);
+      expect(connectedCallback).toHaveBeenCalledWith(DEFAULT_AUTH_RESPONSE);
+
+      expect(onAuth).toHaveBeenCalled();
+      expect(onAuth.mock.calls[0]).toMatchInlineSnapshot(`
+[
+  {
+    "callback_id": 1,
+    "data": {
+      "grant_type": "refresh_token",
+      "refresh_token": "refresh token",
+    },
+    "method": "POST",
+    "path": "sessions/authorize",
+  },
+]
+`);
+
+      expect(response).toEqual(DEFAULT_AUTH_RESPONSE);
       expect(socket.isConnected()).toEqual(true);
 
       expect(mockConsole.warn.mock.calls.length).toBe(0);
@@ -75,7 +110,7 @@ describe('socket', () => {
     test('should handle invalid credentials', async () => {
       server.addErrorHandler('POST', ApiConstants.LOGIN_URL, 'Invalid username or password', 401);
 
-      const { socket, mockConsole } = getSocket();
+      const { socket } = getMockSocket();
       let error;
 
       try {
@@ -94,7 +129,8 @@ describe('socket', () => {
 
     test('should handle connect with custom credentials', async () => {
       server.stop();
-      const { socket } = getSocket({
+      const { socket } = getOriginalSocket({
+        ...getDefaultSocketOptions(),
         username: 'dummy',
         password: 'dummy',
       });
@@ -102,7 +138,7 @@ describe('socket', () => {
       // Fail without a server handler with auto reconnect disabled
       let error;
       try {
-        await socket.connect(CONNECT_PARAMS.username, CONNECT_PARAMS.password, false);
+        await socket.connect(DEFAULT_CONNECT_CREDENTIALS.username, DEFAULT_CONNECT_CREDENTIALS.password, false);
       } catch (e) {
         error = e;
       }
@@ -111,10 +147,10 @@ describe('socket', () => {
       await waitForExpect(() => expect(socket.isActive()).toEqual(false));
 
       // Valid connect attempt
-      server = getMockServer();
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, AUTH_RESPONSE);
+      server = getOriginalMockServer();
+      server.addRequestHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
 
-      await socket.connect(CONNECT_PARAMS.username, CONNECT_PARAMS.password, false);
+      await socket.connect(DEFAULT_CONNECT_CREDENTIALS.username, DEFAULT_CONNECT_CREDENTIALS.password, false);
 
       expect(socket.isConnected()).toEqual(true);
 
@@ -126,27 +162,28 @@ describe('socket', () => {
       const sessionResetCallback = jest.fn();
       const disconnectedCallback = jest.fn();
 
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
       socket.onSessionReset = sessionResetCallback;
       socket.onDisconnected = disconnectedCallback;
 
       // Dummy listener
-      server.addDataHandler('POST', 'hubs/listeners/hub_updated', undefined);
+      server.addRequestHandler('POST', 'hubs/listeners/hub_updated', undefined);
       await socket.addListener('hubs', 'hub_updated', dummyfn);
 
       // Dummy pending request
-      socket.delete('dummyLogoutDelete').catch((error: Error) => {
-        // TODO: fix, too unreliable at the moment (depends on the timings)
-        //expect(error.message).toEqual('Socket disconnected');
-      });
+      server.ignoreMissingHandler('DELETE', 'dummyLogoutDelete');
+
+      const pendingRequestPromise = defusedPromise(socket.delete('dummyLogoutDelete'));
 
       // Logout
-      server.addDataHandler('DELETE', ApiConstants.LOGOUT_URL);
+      server.addRequestHandler('DELETE', ApiConstants.LOGOUT_URL);
       await socket.logout();
 
       expect(sessionResetCallback.mock.calls.length).toBe(1);
       await waitForExpect(() => expect(disconnectedCallback.mock.calls.length).toBe(1));
 
+      await expect(pendingRequestPromise).rejects.toMatchInlineSnapshot(`"Socket disconnected"`);
+
       expect(socket.isActive()).toEqual(false);
       expect(socket.hasListeners()).toEqual(false);
       expect(socket.getPendingRequestCount()).toEqual(0);
@@ -158,7 +195,7 @@ describe('socket', () => {
 
   describe('disconnect', () => {
     test('should handle disconnect', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
       socket.disconnect();
 
@@ -170,16 +207,16 @@ describe('socket', () => {
     });
 
     test('should handle wait disconnected timeout', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
-      let error;
+      let error: Error | null = null;
       try {
         await socket.waitDisconnected(50);
       } catch (e) {
         error = e;
       }
 
-      expect(error).toEqual('Socket disconnect timed out');
+      expect(error?.message).toEqual('Socket disconnect timed out');
 
       expect(mockConsole.error.mock.calls.length).toBe(1);
       expect(mockConsole.warn.mock.calls.length).toBe(0);
@@ -191,19 +228,14 @@ describe('socket', () => {
 
   describe('reconnect', () => {
     test('should handle auto reconnect', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
-      useFakeTimers();
+      jest.useFakeTimers();
 
       socket.disconnect(true);
       jest.runOnlyPendingTimers();
       
-      // TODO: fix
-      /*{
-        const waitForExpectTask = await waitForExpect(() => expect(socket.isActive()).toEqual(false));
-        jest.advanceTimersByTime(1000);
-        await waitForExpectTask;
-      }*/
+      expect(socket.isActive()).toEqual(false);
 
       // Let it fail once
       server.stop();
@@ -211,8 +243,8 @@ describe('socket', () => {
       jest.runOnlyPendingTimers();
       expect(mockConsole.error.mock.calls.length).toBe(1);
 
-      server = getMockServer();
-      server.addDataHandler('POST', ApiConstants.CONNECT_URL, undefined);
+      server = getOriginalMockServer();
+      server.addRequestHandler('POST', ApiConstants.CONNECT_URL, undefined);
       jest.runOnlyPendingTimers();
       jest.runOnlyPendingTimers();
       jest.runOnlyPendingTimers();
@@ -232,9 +264,9 @@ describe('socket', () => {
     });
 
     test('should cancel auto reconnect', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
-      useFakeTimers();
+      jest.useFakeTimers();
 
       // Disconnect with auto reconnect
       socket.disconnect(true);
@@ -258,12 +290,12 @@ describe('socket', () => {
     });
 
     test('should handle manual reconnect', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
       socket.disconnect();
       await waitForExpect(() => expect(socket.isActive()).toEqual(false));
 
-      server.addDataHandler('POST', ApiConstants.CONNECT_URL, undefined);
+      server.addRequestHandler('POST', ApiConstants.CONNECT_URL, undefined);
       await socket.reconnect();
       expect(socket.isConnected()).toEqual(true);
 
@@ -274,39 +306,31 @@ describe('socket', () => {
       await waitForExpect(() => expect(socket.isActive()).toEqual(false));
     });
 
-    // TODO: fix
-    test.skip('should re-authenticate on lost session', async () => {
+    test('should re-authenticate on lost session', async () => {
       const ErrorResponse = 'Invalid session token';
+      const authCallback = jest.fn();
+      const connectErrorCallback = jest.fn();
 
       // Connect and disconnect
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket({
+        authCallback,
+      });
 
-      useFakeTimers();
+      jest.useFakeTimers();
       socket.disconnect();
       jest.runOnlyPendingTimers();
       expect(socket.isActive()).toEqual(false);
 
       // Fail the initial reconnect attempt with 'Invalid session token'
       // and connect with credentials afterwards
-      server.addErrorHandler('POST', ApiConstants.CONNECT_URL, ErrorResponse, 400);
-      
-      const authCallback = jest.fn();
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, AUTH_RESPONSE, authCallback);
+      server.addErrorHandler('POST', ApiConstants.CONNECT_URL, ErrorResponse, 400, connectErrorCallback);
 
       jest.runOnlyPendingTimers();
       socket.reconnect();
 
-      {
-        const waitForExpectTask = waitForExpect(
-          () => {
-            jest.runOnlyPendingTimers();
-            expect(authCallback.mock.calls.length).toBe(1);
-          }
-        );
-
-        jest.advanceTimersByTime(1000);
-        await waitForExpectTask;
-      }
+      await jest.advanceTimersByTimeAsync(1000);
+      expect(authCallback.mock.calls.length).toBe(2);
+      expect(connectErrorCallback.mock.calls.length).toBe(1);
 
       expect(socket.isConnected()).toEqual(true);
       expect(mockConsole.error.mock.calls.length).toBe(0);
@@ -332,9 +356,12 @@ describe('socket', () => {
 
   describe('requests', () => {
     test('should report request timeouts', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
-      useFakeTimers();
+      server.ignoreMissingHandler('POST', 'hubs/listeners/hub_updated');
+      server.ignoreMissingHandler('POST', 'hubs/listeners/hub_added');
+
+      jest.useFakeTimers();
       socket.addListener('hubs', 'hub_updated', dummyfn)
         .catch(() => {});
       socket.addListener('hubs', 'hub_added', dummyfn)
@@ -359,7 +386,7 @@ describe('socket', () => {
     });
 
     test('should handle missing error messages', async () => {
-      const { socket } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
       server.addErrorHandler('POST', 'test/test', null, 401);
 
@@ -393,9 +420,9 @@ describe('socket', () => {
     };
 
     test('should handle listener messages', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
-      server.addDataHandler('POST', 'hubs/listeners/hub_updated', undefined);
-      server.addDataHandler('POST', `hubs/${entityId}/listeners/hub_updated`, undefined);
+      const { socket } = await getConnectedMockSocket();
+      server.addSubscriptionHandler('hubs', 'hub_updated');
+      server.addSubscriptionHandler('hubs', 'hub_updated', entityId);
 
       const commonSubscriptionCallback = jest.fn();
       const entitySubscriptionCallback = jest.fn();
@@ -419,10 +446,9 @@ describe('socket', () => {
     });
 
     test('should handle listener removal', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
 
-      const subscribeCallback = jest.fn();
-      server.addDataHandler('POST', 'hubs/listeners/hub_updated', undefined, subscribeCallback);
+      const hubUpdatedListener = server.addSubscriptionHandler('hubs', 'hub_updated');
 
       // Add two simultaneous pending add events
       const p1 = socket.addListener('hubs', 'hub_updated', dummyfn);
@@ -434,17 +460,14 @@ describe('socket', () => {
       const removeListener1 = await p1;
       const removeListener2 = await p2;
 
-      expect(subscribeCallback.mock.calls.length).toBe(1);
+      expect(hubUpdatedListener.subscribeFn.mock.calls.length).toBe(1);
       expect(socket.getPendingSubscriptionCount()).toBe(0);
 
-      const deleteCallback = jest.fn();
-      server.addDataHandler('DELETE', 'hubs/listeners/hub_updated', undefined, deleteCallback);
-
       removeListener1();
-      expect(deleteCallback.mock.calls.length).toBe(0); // Shouldn't call API yet, still one left
+      expect(hubUpdatedListener.unsubscribeFn.mock.calls.length).toBe(0); // Shouldn't call API yet, still one left
 
-      removeListener2();
-      await waitForExpect(() => expect(deleteCallback.mock.calls.length).toBe(1));
+      await removeListener2();
+      await waitForExpect(() => expect(hubUpdatedListener.unsubscribeFn.mock.calls.length).toBe(1));
 
       expect(socket.hasListeners()).toBe(false);
 
@@ -455,7 +478,7 @@ describe('socket', () => {
     });
 
     test('should handle view updates', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
       const viewUpdateCallback = jest.fn();
 
       const removeListener = socket.addViewUpdateListener('hub_user_view', viewUpdateCallback, entityId);
@@ -472,11 +495,9 @@ describe('socket', () => {
   });
 
   describe('hooks', () => {
-    const hookEventData: IncomingSubscriptionEvent = {
-      event: 'queue_bundle_finished_hook',
-      data: {},
-      completion_id: 1,
-    };
+    const HOOK_MODULE = 'queue';
+    const HOOK_NAME = 'queue_bundle_finished_hook';
+    const HOOK_COMPLETION_ID = 1;
 
     const hookSubscriberInfo: HookSubscriberInfo = {
       id: 'sfv_checker', 
@@ -488,38 +509,32 @@ describe('socket', () => {
     };
 
     test('should handle hook actions', async () => {
-      const { socket, mockConsole } = await getConnectedSocket(server);
+      const { socket } = await getConnectedMockSocket();
       let removeListener: SubscriptionRemoveHandler | null = null;
 
       // Add hook
       {
-        const hookAddCallback = jest.fn();
-        server.addDataHandler('POST', 'queue/hooks/queue_bundle_finished_hook', undefined, hookAddCallback);
+        const hook = server.addHookHandler(HOOK_MODULE, HOOK_NAME);
 
         removeListener = await socket.addHook(
-          'queue', 
-          'queue_bundle_finished_hook', 
+          HOOK_MODULE, 
+          HOOK_NAME, 
           rejectCallback, 
           hookSubscriberInfo
         );
 
-        expect((hookAddCallback.mock.calls[0][0] as any).data).toEqual(hookSubscriberInfo);
-        expect(hookAddCallback.mock.calls.length).toBe(1);
-      }
+        expect((hook.subscribeFn.mock.calls[0][0] as any).data).toEqual(hookSubscriberInfo);
+        expect(hook.subscribeFn.mock.calls.length).toBe(1);
 
-      // Simulate action
-      {
-        const hookEventCallback = jest.fn();
-        server.addDataHandler('POST', 'queue/hooks/queue_bundle_finished_hook/1/reject', undefined, hookEventCallback);
-        server.send(hookEventData);
-        await waitForExpect(() => expect(hookEventCallback.mock.calls.length).toBe(1));
+        // Simulate action
+        const hookResolver = hook.addResolver(HOOK_COMPLETION_ID);
+        hookResolver.fire({});
+        await waitForExpect(() => expect(hookResolver.rejectFn.mock.calls.length).toBe(1));
       }
 
       // Clean up
-      {
-        removeListener();
-        expect(socket.hasListeners()).toBe(false);
-      }
+      await removeListener();
+      expect(socket.hasListeners()).toBe(false);
 
       expect(mockConsole.warn.mock.calls.length).toBe(0);
 
@@ -530,8 +545,11 @@ describe('socket', () => {
 
   describe('logging', () => {
     const connect = async (logLevel: string) => {
-      const { socket, mockConsole } = await getConnectedSocket(server, {
-        logLevel,
+      const { socket } = await getOriginalConnectedSocket(server, {
+        socketOptions: {
+          logLevel,
+          ...getDefaultSocketOptions(),
+        },
       });
 
       socket.disconnect(true);

package/src/tests/mocks/index.ts

@@ -0,0 +1,3 @@
+export * from './mock-data.js';
+export * from './mock-server.js';
+export * from './mock-socket.js';

package/src/tests/mocks/mock-data.ts

@@ -0,0 +1,36 @@
+export const MOCK_SERVER_URL = 'ws://localhost:7171/api/v1/';
+
+export const DEFAULT_CONNECT_CREDENTIALS = {
+  username: 'test',
+  password: 'test',
+};
+
+export const DEFAULT_CONNECT_RESPONSE = {
+  session_id: 1,
+  auth_token: 'b823187f-4aab-4b71-9764-e63e88401a26',
+  token_type: 'Bearer',
+  user: {
+    permissions: [ 'admin' ],
+    username: 'test',
+    active_sessions: 1,
+    last_login: 0,
+  },
+  system_info: {
+    api_version: 1,
+    api_feature_level: 0,
+    cid: 'AHLUODI2YZ2U7FDWMHFNJU65ERGKUN4MH7GW5LY',
+    hostname: 'ubuntu-htpc',
+    network_type: 'private',
+    path_separator: '/',
+    platform: 'other',
+    language: 'fi',
+    client_started: 1483972366,
+    client_version: 'AirDC++w 2.14.0b-39-g3af3 x86_64',
+  },
+  wizard_pending: false,
+};
+
+export const DEFAULT_AUTH_RESPONSE = {
+  ...DEFAULT_CONNECT_RESPONSE,
+  refresh_token: '5124faasf-4aab-4b71-9764-e63e88401a26',
+}