airdcpp-apisocket 3.0.0-beta.5 → 3.0.0-beta.7

package/src/tests/Socket.test.ts

@@ -1,7 +1,7 @@
 import { 
   DEFAULT_AUTH_RESPONSE, DEFAULT_CONNECT_PARAMS, 
-  getConnectedSocket, getMockServer, getSocket, waitForExpect
-} from './helpers.js';
+  getConnectedSocket, getMockServer, getSocket
+} from './mock-server.js';
 
 import ApiConstants from '../ApiConstants.js';
 
@@ -9,6 +9,7 @@ import { HookCallback, HookSubscriberInfo, SubscriptionRemoveHandler } from '../
 import { IncomingSubscriptionEvent } from '../types/api_internal.js';
 
 import { jest } from '@jest/globals';
+import { defusedPromise, waitForExpect } from './test-utils.js';
 
 let server: ReturnType<typeof getMockServer>;
 
@@ -29,7 +30,7 @@ describe('socket', () => {
 
   describe('auth', () => {
     test('should handle valid credentials', async () => {
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
+      server.addRequestHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
       const connectedCallback = jest.fn();
 
       const { socket, mockConsole } = getSocket();
@@ -48,7 +49,7 @@ describe('socket', () => {
     });
 
     test('should handle valid refresh token', async () => {
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
+      server.addRequestHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
       const connectedCallback = jest.fn();
 
       const { socket, mockConsole } = getSocket();
@@ -106,7 +107,7 @@ describe('socket', () => {
 
       // Valid connect attempt
       server = getMockServer();
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
+      server.addRequestHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE);
 
       await socket.connect(DEFAULT_CONNECT_PARAMS.username, DEFAULT_CONNECT_PARAMS.password, false);
 
@@ -125,22 +126,23 @@ describe('socket', () => {
       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);
@@ -166,14 +168,14 @@ describe('socket', () => {
     test('should handle wait disconnected timeout', async () => {
       const { socket, mockConsole } = await getConnectedSocket(server);
 
-      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);
@@ -192,12 +194,7 @@ describe('socket', () => {
       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();
@@ -206,7 +203,7 @@ describe('socket', () => {
       expect(mockConsole.error.mock.calls.length).toBe(1);
 
       server = getMockServer();
-      server.addDataHandler('POST', ApiConstants.CONNECT_URL, undefined);
+      server.addRequestHandler('POST', ApiConstants.CONNECT_URL, undefined);
       jest.runOnlyPendingTimers();
       jest.runOnlyPendingTimers();
       jest.runOnlyPendingTimers();
@@ -257,7 +254,7 @@ describe('socket', () => {
       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);
 
@@ -268,9 +265,10 @@ 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);
@@ -282,25 +280,16 @@ describe('socket', () => {
 
       // Fail the initial reconnect attempt with 'Invalid session token'
       // and connect with credentials afterwards
-      server.addErrorHandler('POST', ApiConstants.CONNECT_URL, ErrorResponse, 400);
+      server.addErrorHandler('POST', ApiConstants.CONNECT_URL, ErrorResponse, 400, connectErrorCallback);
       
-      const authCallback = jest.fn();
-      server.addDataHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE, authCallback);
+      server.addRequestHandler('POST', ApiConstants.LOGIN_URL, DEFAULT_AUTH_RESPONSE, authCallback);
 
       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(1);
+      expect(connectErrorCallback.mock.calls.length).toBe(1);
 
       expect(socket.isConnected()).toEqual(true);
       expect(mockConsole.error.mock.calls.length).toBe(0);
@@ -328,6 +317,9 @@ describe('socket', () => {
     test('should report request timeouts', async () => {
       const { socket, mockConsole } = await getConnectedSocket(server);
 
+      server.ignoreMissingHandler('POST', 'hubs/listeners/hub_updated');
+      server.ignoreMissingHandler('POST', 'hubs/listeners/hub_added');
+
       jest.useFakeTimers();
       socket.addListener('hubs', 'hub_updated', dummyfn)
         .catch(() => {});
@@ -388,8 +380,8 @@ 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);
+      server.addSubscriptionHandler('hubs', 'hub_updated');
+      server.addSubscriptionHandler('hubs', 'hub_updated', entityId);
 
       const commonSubscriptionCallback = jest.fn();
       const entitySubscriptionCallback = jest.fn();
@@ -415,8 +407,7 @@ describe('socket', () => {
     test('should handle listener removal', async () => {
       const { socket, mockConsole } = await getConnectedSocket(server);
 
-      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);
@@ -428,17 +419,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 waitForExpect(() => expect(hubUpdatedListener.unsubscribeFn.mock.calls.length).toBe(1));
 
       expect(socket.hasListeners()).toBe(false);
 
@@ -466,11 +454,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', 
@@ -487,33 +473,27 @@ describe('socket', () => {
 
       // 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);
-      }
+      removeListener();
+      expect(socket.hasListeners()).toBe(false);
 
       expect(mockConsole.warn.mock.calls.length).toBe(0);
 

package/src/tests/mock-server.ts

@@ -0,0 +1,336 @@
+import { Socket } from '../NodeSocket.js';
+import { Client, Server, WebSocket } from 'mock-socket';
+import { jest } from '@jest/globals';
+
+import { OutgoingRequest, RequestSuccessResponse, RequestErrorResponse } from '../types/api_internal.js';
+import * as Options from '../types/options.js';
+import ApiConstants from '../ApiConstants.js';
+import { EventEmitter } from 'events';
+
+const VERBOSE = false;
+
+export const getMockConsole = () => ({
+  log: jest.fn((a1: any, a2: any, a3: any, a4: any) => {
+    if (VERBOSE) {
+      console.log(a1, a2, a3, a4);
+    }
+  }),
+  info: jest.fn((a1: any, a2: any, a3: any, a4: any) => {
+    if (VERBOSE) {
+      console.info(a1, a2, a3, a4);
+    }
+  }),
+  warn: jest.fn((a1: any, a2: any, a3: any, a4: any) => {
+    console.warn(a1, a2, a3, a4);
+  }),
+  error: jest.fn((a1: any, a2: any, a3: any, a4: any) => {
+    console.error(a1, a2, a3, a4);
+  }),
+});
+
+const DEFAULT_CONNECT_PARAMS = {
+  username: 'test',
+  password: 'test',
+  url: 'ws://localhost:7171/api/v1/',
+};
+
+const getDefaultSocketOptions = (mockConsole: Options.LogOutput): Options.APISocketOptions => ({
+  ...DEFAULT_CONNECT_PARAMS,
+  logOutput: mockConsole,
+  logLevel: VERBOSE ? 'verbose' : 'warn',
+});
+
+const DEFAULT_AUTH_RESPONSE = {
+  auth_token: 'b823187f-4aab-4b71-9764-e63e88401a26',
+  refresh_token: '5124faasf-4aab-4b71-9764-e63e88401a26',
+  user: {
+    permissions: [ 'admin' ],
+    username: 'test',
+    active_sessions: 1,
+    last_login: 0,
+  },
+  system: {
+    cid: 'AHLUODI2YZ2U7FDWMHFNJU65ERGKUN4MH7GW5LY',
+    hostname: 'ubuntu-htpc',
+    network_type: 'private',
+    path_separator: '/',
+    platform: 'other',
+    language: 'fi',
+  },
+  wizard_pending: false,
+};
+
+export type MockSocketOptions = Omit<Options.APISocketOptions, 'username' | 'password' | 'url'> & {
+  username?: string;
+  password?: string;
+  url?: string;
+};
+
+const getSocket = (socketOptions: MockSocketOptions = {}, mockConsole = getMockConsole()) => {
+  const socket = Socket(
+    {
+      ...getDefaultSocketOptions(mockConsole),
+      ...socketOptions,
+    }, 
+    WebSocket as any
+  );
+  
+  return { socket, mockConsole };
+};
+
+
+type Callback = (requestData: object) => void;
+
+interface ConnectOptions {
+  socketOptions?: MockSocketOptions;
+  authCallback?: Callback;
+  authResponse?: object;
+  console?: ReturnType<typeof getMockConsole>;
+}
+
+const getDefaultConnectOptions = () => ({
+  console: getMockConsole(),
+  authResponse: DEFAULT_AUTH_RESPONSE,
+});
+
+const getConnectedSocket = async (
+  server: ReturnType<typeof getMockServer>, 
+  userOptions?: ConnectOptions,
+) => {
+  const options = {
+    ...getDefaultConnectOptions(),
+    ...userOptions,
+  };
+
+  server.addRequestHandler('POST', ApiConstants.LOGIN_URL, options.authResponse, options.authCallback);
+
+  const { socket, mockConsole } = getSocket(options.socketOptions, options.console);
+  await socket.connect();
+
+  return { socket, mockConsole };
+};
+
+const toEmitId = (path: string, method: string) => {
+  return `${path}_${method}`;
+};
+
+interface MockServerOptions {
+  url: string;
+  reportMissingListeners?: boolean;
+}
+
+const DEFAULT_MOCK_SERVER_OPTIONS: MockServerOptions = {
+  url: DEFAULT_CONNECT_PARAMS.url,
+  reportMissingListeners: true,
+}
+
+type MockRequestResponseDataObject<DataT extends object | undefined> = Omit<RequestSuccessResponse<DataT>, 'callback_id'> | Omit<RequestErrorResponse, 'callback_id'>;
+type MockRequestResponseDataHandler<DataT extends object | undefined> = (request: OutgoingRequest, s: WebSocket) => MockRequestResponseDataObject<DataT>;
+type MockRequestResponseData<DataT extends object | undefined> = MockRequestResponseDataObject<DataT> | MockRequestResponseDataHandler<DataT>;
+
+const getMockServer = (initialOptions: Partial<MockServerOptions> = {}) => {
+  const { url, reportMissingListeners }: MockServerOptions = {
+    ...DEFAULT_MOCK_SERVER_OPTIONS,
+    ...initialOptions,
+  };
+
+  const mockServer = new Server(url);
+  let socket: Client;
+  const emitter = new EventEmitter();
+
+  const send = (data: object) => {
+    socket.send(JSON.stringify(data));
+  };
+
+  const addServerHandler = <DataT extends object | undefined>(
+    method: string, 
+    path: string, 
+    responseData: MockRequestResponseData<DataT>,
+    subscriptionCallback?: Callback
+  ) => {
+    emitter.addListener(
+      toEmitId(path, method), 
+      (request: OutgoingRequest, s: WebSocket) => {
+        if (subscriptionCallback) {
+          subscriptionCallback(request);
+        }
+
+        const data = typeof responseData === 'function' ? responseData(request, s) : responseData;
+        const response: RequestSuccessResponse | RequestErrorResponse = {
+          callback_id: request.callback_id,
+          ...data,
+        };
+
+        s.send(JSON.stringify(response));
+      }
+    );
+  };
+
+  const addDummyDataHandler = (method: string, path: string) => {
+    emitter.addListener(
+      toEmitId(path, method), 
+      (request: OutgoingRequest, s: WebSocket) => {
+        // Do nothing
+      }
+    );
+  }
+
+  const addRequestHandler = <DataT extends object | undefined>(
+    method: string, 
+    path: string, 
+    data?: DataT | MockRequestResponseDataHandler<DataT>, 
+    subscriptionCallback?: Callback
+  ) => {
+    const handlerData = typeof data === 'function' ? data : {
+      data,
+      code: data ? 200 : 204,
+    }
+
+    addServerHandler<DataT>(
+      method, 
+      path, 
+      handlerData, 
+      subscriptionCallback
+    );
+  }
+
+  const addErrorHandler = (
+    method: string, 
+    path: string, 
+    errorStr: string | null, 
+    errorCode: number, 
+    subscriptionCallback?: Callback
+  ) => {
+    addServerHandler(
+      method, 
+      path, 
+      {
+        error: !errorStr ? null as any : {
+          message: errorStr,
+        },
+        code: errorCode,
+      }, 
+      subscriptionCallback
+    );
+  }
+
+  const addSubscriptionHandlerImpl = (
+    moduleName: string,
+    type: string,
+    listenerName: string,
+    entityId?: string | number,
+  ) => {
+    const subscribeFn = jest.fn();
+    const unsubscribeFn = jest.fn();
+
+    const path = entityId ? `${moduleName}/${entityId}/${type}/${listenerName}` : `${moduleName}/${type}/${listenerName}`;
+
+    addRequestHandler('POST', path, undefined, subscribeFn);
+    addRequestHandler('DELETE', path, undefined, unsubscribeFn);
+
+    const fire = (data: object, entityId?: string | number) => {
+      send({
+        event: listenerName,
+        data,
+        id: entityId,
+      });
+    }
+
+    return {
+      fire,
+
+      subscribeFn,
+      unsubscribeFn,
+
+      path,
+    }
+  }
+  
+
+  const addSubscriptionHandler = (
+    moduleName: string,
+    listenerName: string,
+    entityId?: string | number,
+  ) => {
+    return addSubscriptionHandlerImpl(moduleName, 'listeners', listenerName, entityId);
+  }
+
+  const addHookHandler = (
+    moduleName: string,
+    listenerName: string,
+  ) => {
+    const subscriber = addSubscriptionHandlerImpl(moduleName, 'hooks', listenerName);
+
+    const addResolver = (completionId: number) => {
+      const resolveFn = jest.fn();
+      const rejectFn = jest.fn();
+
+      addRequestHandler(
+        'POST', 
+        `${subscriber.path}/${completionId}/resolve`, 
+        undefined, 
+        resolveFn
+      );
+
+      addRequestHandler(
+        'POST', 
+        `${subscriber.path}/${completionId}/reject`, 
+        undefined, 
+        rejectFn
+      );
+
+      const fire = (data: object) => {
+        send({
+          event: listenerName,
+          data,
+          completion_id: completionId,
+        });
+      }
+
+      return { fire, resolveFn, rejectFn };
+    };
+
+    return {
+      addResolver,
+
+      ...subscriber,
+    }
+  }
+
+
+  mockServer.on('connection', s => {
+    socket = s;
+
+    socket.on('message', (messageObj) => {
+      const request: OutgoingRequest = JSON.parse(messageObj as string);
+      const emitId = toEmitId(request.path, request.method);
+      const processed = emitter.emit(emitId, request, s);
+      if (reportMissingListeners && !processed) {
+        console.warn(`Mock server: no listeners for event ${request.method} ${request.path}`);
+      }
+    });
+  });
+
+  mockServer.on('close', () => {
+    emitter.removeAllListeners();
+  });
+
+  return {
+    addRequestHandler,
+    addErrorHandler,
+
+    addSubscriptionHandler,
+    addHookHandler,
+
+    ignoreMissingHandler: addDummyDataHandler,
+    stop: () => {
+      mockServer.stop(() => {
+        // ...
+      });
+    },
+    send,
+    url,
+  };
+};
+
+export { getMockServer, getSocket, getConnectedSocket, DEFAULT_CONNECT_PARAMS, DEFAULT_AUTH_RESPONSE };