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

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

@@ -0,0 +1,276 @@
+import { Client, Server, WebSocket } from 'mock-socket';
+
+import { OutgoingRequest, RequestSuccessResponse, RequestErrorResponse } from '../../types/api_internal.js';
+import { EventEmitter } from 'events';
+import { MOCK_SERVER_URL } from './mock-data.js';
+
+interface MockFunctionCreator {
+  fn: (...args: any[]) => any;
+};
+
+type RequestCallback = (requestData: object) => void;
+
+const toEmitId = (path: string, method: string) => {
+  return `${path}_${method}`;
+};
+
+const getDefaultMockCreatorF = () => ({
+  fn: () => {},
+});
+
+interface MockServerOptions {
+  url: string;
+  reportMissingListeners?: boolean;
+  mockF: MockFunctionCreator;
+}
+
+const DEFAULT_MOCK_SERVER_OPTIONS: MockServerOptions = {
+  url: MOCK_SERVER_URL,
+  reportMissingListeners: true,
+  mockF: getDefaultMockCreatorF(),
+}
+
+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, mockF }: MockServerOptions = {
+    ...DEFAULT_MOCK_SERVER_OPTIONS,
+    ...initialOptions,
+  };
+
+  const mockServer = new Server(url);
+  let socket: Client;
+  const emitter = new EventEmitter();
+  emitter.setMaxListeners(1);
+
+  const send = (data: object) => {
+    socket.send(JSON.stringify(data));
+  };
+
+  const handlers: Map<string, () => any> = new Map();
+
+  const addServerHandler = <DataT extends object | undefined>(
+    method: string, 
+    path: string, 
+    responseData: MockRequestResponseData<DataT>,
+    subscriptionCallback?: RequestCallback,
+  ) => {
+    const requestHandler = (request: OutgoingRequest, s: WebSocket) => {
+      if (subscriptionCallback) {
+        subscriptionCallback(request);
+      }
+
+      const data = typeof responseData === 'function' ? responseData(request, s) : responseData;
+      if (!data ||!data.code) {
+        throw new Error(`Mock server: response handler for path ${path} must return a status code`);
+      }
+
+      const response: RequestSuccessResponse | RequestErrorResponse = {
+        callback_id: request.callback_id,
+        ...data,
+      };
+
+      s.send(JSON.stringify(response));
+    };
+
+    // Don't add duplicates
+    const emitId = toEmitId(path, method);
+    const removeExisting = handlers.get(emitId);
+    if (removeExisting) {
+      removeExisting();
+      handlers.delete(emitId);
+    }
+
+    // Add new
+    emitter.addListener(emitId, requestHandler);
+
+    // Prepare for removal
+    const removeListener = () => emitter.removeListener(emitId, requestHandler);
+    handlers.set(emitId, removeListener)
+    return removeListener;
+  };
+
+  const addDummyDataHandler = (method: string, path: string) => {
+    const handler = (request: OutgoingRequest, s: WebSocket) => {
+      // Do nothing
+    };
+
+    const emitId = toEmitId(path, method);
+    emitter.addListener(
+      emitId, 
+      handler
+    );
+    emitter.setMaxListeners(1);
+
+    return () => emitter.removeListener(emitId, handler);
+  }
+
+  const addRequestHandler = <DataT extends object | undefined>(
+    method: string, 
+    path: string, 
+    data?: DataT | MockRequestResponseDataHandler<DataT>, 
+    subscriptionCallback?: RequestCallback
+  ) => {
+    const handlerData = typeof data === 'function' ? data : {
+      data,
+      code: data ? 200 : 204,
+    }
+
+    return addServerHandler<DataT>(
+      method, 
+      path, 
+      handlerData, 
+      subscriptionCallback
+    );
+  }
+
+  const addErrorHandler = (
+    method: string, 
+    path: string, 
+    errorStr: string | null, 
+    errorCode: number, 
+    subscriptionCallback?: RequestCallback
+  ) => {
+    return 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 = mockF.fn();
+    const unsubscribeFn = mockF.fn();
+
+    const path = entityId ? `${moduleName}/${entityId}/${type}/${listenerName}` : `${moduleName}/${type}/${listenerName}`;
+
+    const subscribeRemove = addRequestHandler('POST', path, undefined, subscribeFn);
+    const unsubscribeRemove = addRequestHandler('DELETE', path, undefined, unsubscribeFn);
+
+    const fire = (data: object, entityId?: string | number) => {
+      send({
+        event: listenerName,
+        data,
+        id: entityId,
+      });
+    }
+
+    const remove = () => {
+      subscribeRemove();
+      unsubscribeRemove();
+    };
+
+    return {
+      fire,
+      remove,
+
+      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 = mockF.fn();
+      const rejectFn = mockF.fn();
+
+      const resolveRemove = addRequestHandler(
+        'POST', 
+        `${subscriber.path}/${completionId}/resolve`, 
+        undefined, 
+        resolveFn
+      );
+
+      const rejectRemove = addRequestHandler(
+        'POST', 
+        `${subscriber.path}/${completionId}/reject`, 
+        undefined, 
+        rejectFn
+      );
+
+      const remove = () => {
+        resolveRemove();
+        rejectRemove();
+      }
+
+      const fire = (data: object) => {
+        send({
+          event: listenerName,
+          data,
+          completion_id: completionId,
+        });
+      }
+
+      return { fire, remove, 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}`);
+      }
+    });
+  });
+
+  return {
+    addRequestHandler,
+    addErrorHandler,
+
+    addSubscriptionHandler,
+    addHookHandler,
+
+    ignoreMissingHandler: addDummyDataHandler,
+    stop: () => {
+      mockServer.stop(() => {
+        emitter.removeAllListeners();
+        handlers.clear();
+      });
+    },
+    send,
+    url,
+  };
+};
+
+export { getMockServer };

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

@@ -0,0 +1,72 @@
+import { Socket } from '../../NodeSocket.js';
+import { WebSocket } from 'mock-socket';
+
+import * as Options from '../../types/options.js';
+import ApiConstants from '../../ApiConstants.js';
+
+import { getMockServer } from './mock-server.js';
+import { DEFAULT_AUTH_RESPONSE, DEFAULT_CONNECT_CREDENTIALS, MOCK_SERVER_URL } from './mock-data.js';
+
+const getDefaultSocketOptions = (): Options.APISocketOptions => ({
+  url: MOCK_SERVER_URL,
+  logOutput: console,
+  logLevel: 'warn',
+});
+
+export type MockSocketConnectOptions = Omit<Options.APISocketOptions, 'username' | 'password' | 'url'> & {
+  username?: string;
+  password?: string;
+  url?: string;
+};
+
+
+type RequestCallback = (requestData: object) => void;
+
+interface MockSocketOptions {
+  console: Options.LogOutput;
+  socketOptions?: MockSocketConnectOptions;
+}
+
+export interface MockConnectedSocketOptions extends MockSocketOptions {
+  authCallback?: RequestCallback;
+  authResponse: object;
+}
+
+
+export const getSocket = (socketOptions: MockSocketConnectOptions = {}) => {
+  const socket = Socket(
+    {
+      ...getDefaultSocketOptions(),
+      ...socketOptions
+    },
+    WebSocket as any
+  );
+  
+  return { socket };
+};
+
+const getDefaultConnectOptions = () => ({
+  console,
+  authResponse: DEFAULT_AUTH_RESPONSE,
+});
+
+export const getConnectedSocket = async (
+  server: ReturnType<typeof getMockServer>, 
+  userOptions?: Partial<MockConnectedSocketOptions>,
+) => {
+  const options: MockConnectedSocketOptions = {
+    ...getDefaultConnectOptions(),
+    ...userOptions,
+  };
+
+  const removeAuthHandler = server.addRequestHandler('POST', ApiConstants.LOGIN_URL, options.authResponse, options.authCallback);
+
+  const { socket } = getSocket({
+    ...DEFAULT_CONNECT_CREDENTIALS,
+    ...getDefaultSocketOptions(),
+    ...options.socketOptions
+  });
+  await socket.connect();
+
+  return { socket, removeAuthHandler };
+};

package/src/tests/public_helpers.test.ts

@@ -1,15 +1,14 @@
 import { 
   getMockServer,
   getConnectedSocket,
-  waitForExpect,
-} from './helpers.js';
+} from './mocks';
+import { waitForExpect } from './test-utils.js';
 
 import { jest } from '@jest/globals';
 
 import { addContextMenuItems } from '../PublicHelpers.js';
 import { SelectedMenuItemListenerData, MenuItemListHookData, MenuItemListHookAcceptData } from '../types/public_helpers_internal.js';
-import { HookSubscriberInfo } from '../types/index.js';
-import { IncomingSubscriptionEvent } from '../types/api_internal.js';
+import { HookSubscriberInfo, MenuCallbackProperties, MenuClickHandlerProperties } from '../types/index.js';
 
 
 let server: ReturnType<typeof getMockServer>;
@@ -18,7 +17,9 @@ let server: ReturnType<typeof getMockServer>;
 describe('public helpers', () => {
 
   beforeEach(() => {
-    server = getMockServer();
+    server = getMockServer({
+      mockF: jest,
+    });
   });
 
   afterEach(() => {
@@ -97,19 +98,10 @@ describe('public helpers', () => {
       // Socket handlers
       const { socket } = await getConnectedSocket(server);
 
-      const listenerAddCallback = jest.fn();
-      server.addDataHandler('POST', `menus/listeners/${MENU_ID}_menuitem_selected`, undefined, listenerAddCallback);
-
-      const hookAddCallback = jest.fn();
-      const hookResolveCallback = jest.fn();
-      server.addDataHandler('POST', `menus/hooks/${MENU_ID}_list_menuitems`, undefined, hookAddCallback);
-      server.addDataHandler(
-        'POST', 
-        `menus/hooks/${MENU_ID}_list_menuitems/${HOOK_COMPLETION_ID}/resolve`, 
-        menuItemListData, 
-        hookResolveCallback
-      );
+      const itemSelectedListener = server.addSubscriptionHandler('menus', `${MENU_ID}_menuitem_selected`);
 
+      const listItemsHook = server.addHookHandler('menus', `${MENU_ID}_list_menuitems`);
+      const listItemsResolver = listItemsHook.addResolver(HOOK_COMPLETION_ID);
 
       // Add menu items
       const onClickItem1Mock = jest.fn();
@@ -123,42 +115,42 @@ describe('public helpers', () => {
         [
           {
             ...MENU_ITEM1,
-            filter: async (ids, entityId) => {
+            filter: async () => {
               return true;
             },
             access: VALID_ACCESS,
-            onClick: (ids, entityId, permissions, supports, formValues) => {
-              onClickItem1Mock(ids, entityId, permissions, supports, formValues);
+            onClick: (props) => {
+              onClickItem1Mock(props);
             },
-            formDefinitions: (ids, entityId, permissions, supports) => {
+            formDefinitions: () => {
               return FORM_DEFINITIONS;
             },
           }, {
             ...MENU_ITEM2,
-            onClick: (ids, entityId) => {
-              onClickItem2Mock(ids, entityId);
+            onClick: (props) => {
+              onClickItem2Mock(props);
             }
           }, {
             ...MENU_ITEM3,
-            urls: (ids, entityId, permissions, supports) => {
-              onGetUrlsItem3Mock(ids, entityId, permissions, supports);
+            urls: (props) => {
+              onGetUrlsItem3Mock(props);
               return URLS;
             }
           }, {
             id: 'ignored_filter_id',
             title: 'Mock item ignored by filter',
-            filter: (ids, entityId, permissions, supports) => {
+            filter: () => {
               return false;
             },
-            onClick: (ids, entityId, permissions, supports, formValues) => {
-              onClickItemIgnoredMock(ids, entityId, permissions, supports, formValues);
+            onClick: (props) => {
+              onClickItemIgnoredMock(props);
             }
           }, {
             id: 'ignored_access_id',
             title: 'Mock item ignored by access',
             access: 'invalid_access',
-            onClick: (ids, entityId, permissions, supports, formValues) => {
-              onClickItemIgnoredMock(ids, entityId, permissions, supports, formValues);
+            onClick: (props) => {
+              onClickItemIgnoredMock(props);
             }
           }
         ],
@@ -166,33 +158,29 @@ describe('public helpers', () => {
         SUBSCRIBER_INFO,
       );
       
-      expect(listenerAddCallback).toBeCalledTimes(1);
-      expect(hookAddCallback).toBeCalledTimes(1);
+      expect(itemSelectedListener.subscribeFn).toHaveBeenCalledTimes(1);
+      expect(listItemsHook.subscribeFn).toHaveBeenCalledTimes(1);
 
 
       // List items hook
       {
-        const hookEventData: IncomingSubscriptionEvent<MenuItemListHookData<string, null>> = {
-          event: `${MENU_ID}_list_menuitems`,
-          data: {
-            selected_ids: selectedMenuIds,
-            entity_id: null,
-            permissions: PERMISSIONS,
-            supports: SUPPORTS,
-          },
-          completion_id: 1,
+        const menuItemListData: MenuItemListHookData<string, null> = {
+          selected_ids: selectedMenuIds,
+          entity_id: null,
+          permissions: PERMISSIONS,
+          supports: SUPPORTS,
         };
 
-        server.send(hookEventData);
+        listItemsResolver.fire(menuItemListData);
       }
 
       // Validate list items results
       {
         await waitForExpect(() => {
-          expect(hookResolveCallback).toHaveBeenCalledTimes(1);
+          expect(listItemsResolver.resolveFn).toHaveBeenCalledTimes(1);
         });
 
-        expect(hookResolveCallback).toBeCalledWith(
+        expect(listItemsResolver.resolveFn).toHaveBeenCalledWith(
           expect.objectContaining({
             data: menuItemListData
           }),
@@ -201,27 +189,31 @@ describe('public helpers', () => {
         await waitForExpect(() => {
           expect(onGetUrlsItem3Mock).toHaveBeenCalledTimes(1);
         });
-        expect(onGetUrlsItem3Mock).toHaveBeenCalledWith(selectedMenuIds, null, PERMISSIONS, SUPPORTS);
+
+        const urlCallbackProps: MenuCallbackProperties<string, null> = {
+          selectedIds: selectedMenuIds, 
+          entityId: null, 
+          permissions: PERMISSIONS, 
+          supports: SUPPORTS
+        }
+
+        expect(onGetUrlsItem3Mock).toHaveBeenCalledWith(urlCallbackProps);
       }
 
       // Select event listener
       {
-        const selectEventData: IncomingSubscriptionEvent<SelectedMenuItemListenerData<string, null>> = {
-          event: `${MENU_ID}_menuitem_selected`,
-          data: {
-            menuitem_id: MENU_ITEM1_ID,
-            hook_id: SUBSCRIBER_INFO.id,
-            menu_id: MENU_ID,
-            entity_id: null,
-            selected_ids: selectedMenuIds,
-            permissions: PERMISSIONS,
-            supports: SUPPORTS,
-            form_values: FORM_VALUES
-          },
-          completion_id: HOOK_COMPLETION_ID,
+        const selectData: SelectedMenuItemListenerData<string, null> = {
+          menuitem_id: MENU_ITEM1_ID,
+          hook_id: SUBSCRIBER_INFO.id,
+          menu_id: MENU_ID,
+          entity_id: null,
+          selected_ids: selectedMenuIds,
+          permissions: PERMISSIONS,
+          supports: SUPPORTS,
+          form_values: FORM_VALUES
         };
 
-        server.send(selectEventData);
+        itemSelectedListener.fire(selectData);
       }
 
       // Validate select event results
@@ -229,13 +221,22 @@ describe('public helpers', () => {
         await waitForExpect(() => {
           expect(onClickItem1Mock).toHaveBeenCalledTimes(1);
         });
-        expect(onClickItem1Mock).toHaveBeenCalledWith(selectedMenuIds, null, PERMISSIONS, SUPPORTS, FORM_VALUES);
-        expect(onClickItem2Mock).not.toBeCalled();
-        expect(onClickItemIgnoredMock).not.toBeCalled();
+
+        const clickHandlerProps: MenuClickHandlerProperties<string, null> = {
+          selectedIds: selectedMenuIds, 
+          entityId: null, 
+          permissions: PERMISSIONS, 
+          supports: SUPPORTS, 
+          formValues: FORM_VALUES
+        }
+
+        expect(onClickItem1Mock).toHaveBeenCalledWith(clickHandlerProps);
+        expect(onClickItem2Mock).not.toHaveBeenCalled();
+        expect(onClickItemIgnoredMock).not.toHaveBeenCalled();
       }
 
       // Remove items
-      removeMenuItems();
+      await removeMenuItems();
       expect(socket.hasListeners()).toBe(false);
     });
   });

package/src/tests/test-utils.ts

@@ -0,0 +1,31 @@
+import waitForExpectOriginal from 'wait-for-expect';
+
+const EXCEPT_TIMEOUT = 1000;
+//@ts-ignore
+export const waitForExpect = (func: () => void | Promise<void>) => waitForExpectOriginal.default(func, EXCEPT_TIMEOUT);
+
+
+// This is a helper function that will suppress the error of a promise.
+export const defusedPromise = (promise: Promise<any>) => {
+  promise.catch(() => {});
+  return promise;
+}
+
+export const getMockConsole = (verbose = false) => ({
+  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);
+  }),
+});

package/src/types/api_internal.ts

@@ -1,6 +1,5 @@
 // HELPERS
 export type CompletionIdType = number;
-//export type SubscriptionIdType = string;
 
 
 // REQUESTS

package/src/types/public_helpers.ts

@@ -1,29 +1,29 @@
 import { HookSubscriberInfo } from './subscriptions.js';
 
-type AsyncCallbackProperty<IdT, EntityIdT, ReturnT> = (
+export interface MenuCallbackProperties<IdT, EntityIdT> {
   selectedIds: IdT[], 
-  entityId: EntityIdT | null, 
+  entityId: EntityIdT, 
   permissions: string[], 
   supports: string[]
-) => ReturnT | Promise<ReturnT>;
+}
+
+export interface MenuClickHandlerProperties<IdT, EntityIdT, FormValueT extends object = object> extends MenuCallbackProperties<IdT, EntityIdT> {
+  formValues: FormValueT
+}
+
+type AsyncCallbackProperty<IdT, EntityIdT, ReturnT> = (props: MenuCallbackProperties<IdT, EntityIdT>) => ReturnT | Promise<ReturnT>;
 
 export type ContextMenuIcon = { [key in string]: string };
 
 export interface ContextMenu extends HookSubscriberInfo {
   icon?: ContextMenuIcon;
 }
-export interface ContextMenuItem<IdT, EntityIdT> {
+export interface ContextMenuItem<IdT, EntityIdT, FormValueT extends object = object> {
   id: string;
   title: string;
   icon?: ContextMenuIcon;
   urls?: string[] | AsyncCallbackProperty<IdT, EntityIdT, string[] | undefined>;
-  onClick?: (
-    selectedIds: IdT[], 
-    entityId: EntityIdT | null, 
-    permissions: string[], 
-    supports: string[],
-    formValues: object
-  ) => void;
+  onClick?: (props: MenuClickHandlerProperties<IdT, EntityIdT, FormValueT>) => void;
   filter?: AsyncCallbackProperty<IdT, EntityIdT, boolean>;
   access?: string;
   formDefinitions?: object[] | AsyncCallbackProperty<IdT, EntityIdT, object[]>;

package/src/types/public_helpers_internal.ts

@@ -6,7 +6,7 @@ export interface SelectedMenuItemListenerData<IdT, EntityIdT> {
   menu_id: string;
   menuitem_id: string;
   selected_ids: IdT[];
-  entity_id: EntityIdT | null;
+  entity_id: EntityIdT;
   permissions: string[];
   supports: string[];
   form_values: object;
@@ -14,14 +14,14 @@ export interface SelectedMenuItemListenerData<IdT, EntityIdT> {
 
 export interface MenuItemListHookData<IdT, EntityIdT> {
   selected_ids: IdT[];
-  entity_id: EntityIdT | null;
+  entity_id: EntityIdT;
   permissions: string[];
   supports: string[];
 }
 
 export interface ResponseMenuItemCallbackFields {
-  urls?: string[] | undefined;
-  form_definitions?: object[] | undefined;
+  urls?: string[];
+  form_definitions?: object[];
 }
 
 export type ResponseMenuItem<IdT, EntityIdT> = Omit<ContextMenuItem<IdT, EntityIdT>, 'onClick' | 'filter' | 'urls' | 'form_definitions'> & ResponseMenuItemCallbackFields;

package/src/types/socket.ts

@@ -26,4 +26,5 @@ export interface APISocket extends SocketRequestMethods, SocketSubscriptions {
   onSessionReset: SessionResetCallback | null;
   onDisconnected: DisconnectedCallback | null;
   readonly nativeSocket: WebSocket | null;
+  readonly url: string;
 }