aps-data-api/test/mocks/mock-data-extraction/aps-request-handler.ts

package for data extraction from APS company for omnimetic project

import fs from 'fs';
import path from 'path';
import { WaitForOptions } from 'puppeteer';

import { BrowserInterface, LooseObject } from '../../../src/typings';

import { GetServiceAccountsRequestHandlerImpl } from './index';
import { MockResponse } from './mock-response';
import { MockTarget } from './mock-target';
import { RequestHandler } from './request-handler';

const workFlowConfigFilePath = path.join(
  'src',
  'services',
  'workflow',
  'workflow.json',
);
const apsWorkflowJson = JSON.parse(
  fs.readFileSync(workFlowConfigFilePath).toString(),
);

const mockWorkflowPath = path.join(
  'test',
  'mocks',
  'mock-data-extraction',
  'mock-workflow-url.json',
);
const mockWorkflowJSON = JSON.parse(
  fs.readFileSync(mockWorkflowPath).toString(),
);

export class APSRequestHandler implements RequestHandler {
  password: string;
  username: string;
  requestHandler: LooseObject;
  requestHandlerFlow: LooseObject = new Map();

  constructor() {
    this.requestHandlerFlow.set(
      mockWorkflowJSON.userDetailsUrlAPS,
      new GetServiceAccountsRequestHandlerImpl(),
    );
  }

  async type(
    selector: string,
    text: string,
    options?: {
      delay: number;
    },
  ) {
    if (selector === apsWorkflowJson.login.usernameCssId) {
      this.username = text;
    }

    if (selector === apsWorkflowJson.login.passwordCssId) {
      this.password = text;
    }
    return Promise.resolve();
  }

  async goto(
    url: string,
    options?: WaitForOptions & {
      referer?: string;
    },
  ) {
    const requestHandler = this.requestHandlerFactory(url);
    if (!requestHandler) {
      return;
    }
    this.requestHandler = this.requestHandlerFactory(url);

    const mockResponse: BrowserInterface.HTTPResponse = new MockResponse();
    return Promise.resolve(mockResponse);
  }

  async waitForResponse(
    urlOrPredicate:
      | string
      | ((res: BrowserInterface.HTTPResponse) => boolean | Promise<boolean>),
    options?: {
      timeout?: number;
    },
  ) {
    try {
      if (
        (this.username !== 'Naval' || this.password !== 'Podcast') &&
        (this.username !== 'Naval' || this.password !== 'Gurukant')
      ) {
        const data = {
          isLoginSuccess: false,
          error: apsWorkflowJson.login.accessResult,
        };
        return Promise.resolve(data);
      }

      if (
        typeof urlOrPredicate === 'string' &&
        urlOrPredicate.startsWith(
          apsWorkflowJson.getServiceAccounts.userDetailsUrl,
        ) &&
        this.username === 'Naval' &&
        this.password === 'Gurukant'
      ) {
        const data = { error: 'Failed to extract data' };
        return Promise.resolve(data);
      }

      if (
        typeof urlOrPredicate === 'string' &&
        urlOrPredicate.startsWith(
          apsWorkflowJson.getServiceAccounts.userDetailsUrl,
        )
      ) {
        this.requestHandler = this.requestHandlerFlow.get(
          mockWorkflowJSON.userDetailsUrlAPS,
        );

        const data = this.requestHandler.waitForResponse(
          urlOrPredicate,
          options,
        );

        return Promise.resolve(data);
      }

      return Promise.resolve({});
    } catch (err) {
      return Promise.reject(err);
    }
  }

  async waitForSelector(
    selector: string,
    options?: {
      visible?: boolean;
      hidden?: boolean;
      timeout?: number;
    },
  ) {
    try {
      if (selector === 'span.aps-btn-link') {
        return Promise.resolve(null);
      }
      if (selector === apsWorkflowJson.getServiceAccounts.addressDataSelector) {
        return Promise.resolve(null);
      }
    } catch (err) {
      return Promise.reject(err);
    }
  }

  async $eval<ReturnType>(
    selector: string,
    pageFunction: (
      element: Element,
      ...args: unknown[]
    ) => ReturnType | Promise<ReturnType>,
  ) {
    const data = this.requestHandler.$eval(selector, pageFunction);
    return Promise.resolve(data);
  }

  // tslint:disable-next-line: function-name
  async $$(selector: string) {
    const data = this.requestHandler.$$(selector);
    return Promise.resolve(data);
  }

  // tslint:disable-next-line: function-name
  async $$eval<ReturnType>(
    selector: string,
    pageFunction: (
      elements: Element[],
      ...args: unknown[]
    ) => ReturnType | Promise<ReturnType>,
  ) {
    const data = this.requestHandler.$$eval(selector, pageFunction);
    return Promise.resolve(data);
  }

  target() {
    const mockTarget = new MockTarget();
    return mockTarget;
  }

  requestHandlerFactory(url: string) {
    return this.requestHandlerFlow.get(url);
  }
}