add plugin commands to add listeners

Author: sudharsan-selvaraj

package.json

@@ -13,7 +13,7 @@
     "uninstall": "export APPIUM_HOME=/tmp/some-temp-dir && (appium plugin uninstall appium-interceptor || exit 0)",
     "install-plugin": "export APPIUM_HOME=/tmp/some-temp-dir && npm run build && appium plugin install --source=local $(pwd)",
     "reinstall-plugin": "export APPIUM_HOME=/tmp/some-temp-dir && (appium plugin uninstall appium-interceptor || exit 0) && npm run install-plugin",
-    "run-server": "export APPIUM_HOME=/tmp/some-temp-dir && appium server -ka 800 --use-plugins=appium-interceptor -pa /wd/hub "
+    "run-server": "export APPIUM_HOME=/tmp/some-temp-dir && appium server -ka 800 --use-plugins=appium-interceptor -pa /wd/hub"
   },
   "contributors": [
     {

src/api-sniffer.ts

@@ -0,0 +1,33 @@
+import { RequestInfo, SniffConfig } from './types';
+import { doesUrlMatch } from './utils/proxy';
+
+export class ApiSniffer {
+  private readonly requests: RequestInfo[] = [];
+
+  constructor(private id: string, private config: SniffConfig) {}
+
+  getId() {
+    return this.id;
+  }
+
+  onApiRequest(request: RequestInfo) {
+    if (this.doesRequestMatchesConfig(request)) {
+      this.requests.push(request);
+    }
+  }
+
+  getRequests() {
+    return this.requests;
+  }
+
+  private doesRequestMatchesConfig(request: RequestInfo) {
+    const doesIncludeRuleMatches = !this.config.include
+      ? true
+      : this.config.include.some((config) => doesUrlMatch(config.url, request.url));
+    const doesExcludeRuleMatches = !this.config.exclude
+      ? true
+      : !this.config.exclude.some((config) => doesUrlMatch(config.url, request.url));
+
+    return doesIncludeRuleMatches && doesExcludeRuleMatches;
+  }
+}

src/interceptor.ts

@@ -1,10 +1,10 @@
 import { ErrorCallback, IContext } from 'http-mitm-proxy';
 import stream from 'stream';
-import { constructURLFromRequest } from './utils/proxy';
+import { constructURLFromHttpRequest } from './utils/proxy';
 import responseDecoder from './response-decoder';
 import parseHeader from 'parse-headers';
 
-function interceptBody(writable: stream.Writable | undefined, callback: (value: any) => void) {
+function readBodyFromStream(writable: stream.Writable | undefined, callback: (value: any) => void) {
   if (!writable) {
     return callback(null);
   }
@@ -30,26 +30,27 @@ function RequestInterceptor(requestCompletionCallback: (value: any) => void) {
     ctx.use(responseDecoder);
     const requestData = {} as any;
     ctx.onRequestEnd((ctx, callback) => {
-      interceptBody(ctx.proxyToServerRequest, (requestBody) => {
-        requestData['postBody'] = requestBody;
+      readBodyFromStream(ctx.proxyToServerRequest, (requestBody) => {
+        requestData['requestBody'] = requestBody;
         requestData['requestHeaders'] = ctx.proxyToServerRequest?.getHeaders();
       });
       callback();
     });
 
-    interceptBody(ctx.proxyToClientResponse, (response) => {
+    readBodyFromStream(ctx.proxyToClientResponse, (response) => {
       const { headers, url } = ctx.clientToProxyRequest;
       const protocol = ctx.isSSL ? 'https://' : 'http://';
-      const _url = constructURLFromRequest({
+      const _url = constructURLFromHttpRequest({
         host: headers.host!,
         path: url!,
         protocol,
       });
       const responseHeaders = parseHeader((ctx.proxyToClientResponse as any)?._header || '');
-      requestData['url'] = _url;
+      requestData['url'] = _url.toString();
       requestData['method'] = ctx.clientToProxyRequest.method;
       requestData['responseBody'] = response;
       requestData['responseHeaders'] = responseHeaders;
+      requestData['statusCode'] = ctx.proxyToClientResponse.statusCode;
 
       requestCompletionCallback(requestData);
     });

src/plugin.ts

@@ -1,13 +1,12 @@
 import { BasePlugin } from 'appium/plugin';
 import http from 'http';
 import { Application } from 'express';
-import { CliArg, ISessionCapability, MockConfig } from './types';
+import { CliArg, ISessionCapability, MockConfig, SniffConfig } from './types';
 import _ from 'lodash';
 import { configureWifiProxy, isRealDevice } from './utils/adb';
 import { cleanUpProxyServer, sanitizeMockConfig, setupProxyServer } from './utils/proxy';
 import proxyCache from './proxy-cache';
 import logger from './logger';
-import { validateMockConfig } from './schema';
 
 export class AppiumInterceptorPlugin extends BasePlugin {
   static executeMethodMap = {
@@ -20,6 +19,26 @@ export class AppiumInterceptorPlugin extends BasePlugin {
       command: 'removeMock',
       params: { required: ['id'] },
     },
+
+    'interceptor: disableMock': {
+      command: 'disableMock',
+      params: { required: ['id'] },
+    },
+
+    'interceptor: enableMock': {
+      command: 'enableMock',
+      params: { required: ['id'] },
+    },
+
+    'interceptor: startListening': {
+      command: 'startListening',
+      params: { optional: ['config'] },
+    },
+
+    'interceptor: stopListening': {
+      command: 'stopListening',
+      params: { optional: ['id'] },
+    },
   };
 
   constructor(name: string, cliArgs: CliArg) {
@@ -99,6 +118,46 @@ export class AppiumInterceptorPlugin extends BasePlugin {
     proxy.removeMock(id);
   }
 
+  async disableMock(next: any, driver: any, id: any) {
+    const proxy = proxyCache.get(driver.sessionId);
+    if (!proxy) {
+      logger.error('Proxy is not running');
+      throw new Error('Proxy is not active for current session');
+    }
+
+    proxy.disableMock(id);
+  }
+
+  async enableMock(next: any, driver: any, id: any) {
+    const proxy = proxyCache.get(driver.sessionId);
+    if (!proxy) {
+      logger.error('Proxy is not running');
+      throw new Error('Proxy is not active for current session');
+    }
+
+    proxy.enableMock(id);
+  }
+
+  async startListening(next: any, driver: any, config: SniffConfig) {
+    const proxy = proxyCache.get(driver.sessionId);
+    if (!proxy) {
+      logger.error('Proxy is not running');
+      throw new Error('Proxy is not active for current session');
+    }
+
+    return proxy?.addSniffer(config);
+  }
+
+  async stopListening(next: any, driver: any, id: any) {
+    const proxy = proxyCache.get(driver.sessionId);
+    if (!proxy) {
+      logger.error('Proxy is not running');
+      throw new Error('Proxy is not active for current session');
+    }
+
+    return proxy.removeSniffer(id);
+  }
+
   async execute(next: any, driver: any, script: any, args: any) {
     return await this.executeMethod(next, driver, script, args);
   }

src/proxy.ts

@@ -1,4 +1,4 @@
-import { MockConfig } from './types';
+import { MockConfig, RequestInfo, SniffConfig } from './types';
 import { Proxy as HttpProxy, IContext, IProxyOptions } from 'http-mitm-proxy';
 import { v4 as uuid } from 'uuid';
 import {
@@ -15,6 +15,8 @@ import {
 import ResponseDecoder from './response-decoder';
 import { Mock } from './mock';
 import { RequestInterceptor } from './interceptor';
+import { ApiSniffer } from './api-sniffer';
+import _ from 'lodash';
 
 export interface ProxyOptions {
   deviceUDID: string;
@@ -27,6 +29,8 @@ export interface ProxyOptions {
 export class Proxy {
   private _started = false;
   private readonly mocks = new Map<string, Mock>();
+  private readonly sniffers = new Map<string, ApiSniffer>();
+
   private readonly httpProxy: HttpProxy;
 
   public isStarted(): boolean {
@@ -66,9 +70,9 @@ export class Proxy {
 
     this.httpProxy.onRequest(
       RequestInterceptor((requestData: any) => {
-        // console.log('****** REQUEST **********');
-        // console.log(JSON.stringify(requestData, null, 2));
-        // console.log('****************************');
+        for (const sniffer of this.sniffers.values()) {
+          sniffer.onApiRequest(requestData);
+        }
       })
     );
     this.httpProxy.onRequest(this.handleMockApiRequest.bind(this));
@@ -97,6 +101,33 @@ export class Proxy {
     this.mocks.delete(id);
   }
 
+  public enableMock(id: string): void {
+    this.mocks.get(id)?.setEnableStatus(true);
+  }
+
+  public disableMock(id: string): void {
+    this.mocks.get(id)?.setEnableStatus(false);
+  }
+
+  public addSniffer(sniffConfg: SniffConfig): string {
+    const id = uuid();
+    this.sniffers.set(id, new ApiSniffer(id, sniffConfg));
+    return id;
+  }
+
+  public removeSniffer(id?: string): RequestInfo[] {
+    const _sniffers = [...this.sniffers.values()];
+    if (id && !_.isNil(this.sniffers.get(id))) {
+      _sniffers.push(this.sniffers.get(id)!);
+    }
+    const apiRequests = _sniffers.reduce((acc, sniffer) => {
+      acc.push(...sniffer.getRequests());
+      return acc;
+    }, [] as RequestInfo[]);
+    _sniffers.forEach((sniffer) => this.sniffers.delete(sniffer.getId()));
+    return apiRequests;
+  }
+
   private async handleMockApiRequest(ctx: IContext, next: () => void): Promise<void> {
     const matchedMocks = await this.findMatchingMocks(ctx);
     if (matchedMocks.length) {
@@ -122,7 +153,11 @@ export class Proxy {
     const matchedMocks: MockConfig[] = [];
     for (const mock of this.mocks.values()) {
       const config = mock.getConfig();
-      if (doesUrlMatch(config.url, url) && doesHttpMethodMatch(request, config.method)) {
+      if (
+        mock.isEnabled() &&
+        doesUrlMatch(config.url, url) &&
+        doesHttpMethodMatch(request, config.method)
+      ) {
         matchedMocks.push(config);
       }
     }

src/types.ts

@@ -37,3 +37,18 @@ export type MockConfig = {
   responseBody?: string;
   updateResponseBody?: UpdateBodySpec[];
 };
+
+export type SniffConfig = {
+  include?: Array<{ url: UrlPattern }>;
+  exclude?: Array<{ url: UrlPattern }>;
+};
+
+export type RequestInfo = {
+  url: string;
+  method: string;
+  requestBody: any;
+  statusCode: number;
+  requestHeaders: Record<string, string | string[]>;
+  responseBody: any;
+  responseHeaders: Record<string, string | string[]>;
+};