serverless-spy 0.0.0

package/listener/SpyListener.ts

@@ -0,0 +1,104 @@
+import { DynamoDBSpyEvent } from 'serverless-spy-common/spyEvents/DynamoDBSpyEvent';
+import { EventBridgeRuleSpyEvent } from 'serverless-spy-common/spyEvents/EventBridgeRuleSpyEvent';
+import { EventBridgeSpyEvent } from 'serverless-spy-common/spyEvents/EventBridgeSpyEvent';
+import { FunctionConsoleSpyEvent } from 'serverless-spy-common/spyEvents/FunctionConsoleSpyEvent';
+import { FunctionRequestSpyEvent } from 'serverless-spy-common/spyEvents/FunctionRequestSpyEvent';
+import { FunctionResponseSpyEvent } from 'serverless-spy-common/spyEvents/FunctionResponseSpyEvent';
+import { S3SpyEvent } from 'serverless-spy-common/spyEvents/S3SpyEvent';
+import { SnsSubscriptionSpyEvent } from 'serverless-spy-common/spyEvents/SnsSubscriptionSpyEvent';
+import { SnsTopicSpyEvent } from 'serverless-spy-common/spyEvents/SnsTopicSpyEvent';
+import { SqsSpyEvent } from 'serverless-spy-common/spyEvents/SqsSpyEvent';
+
+import { WaitForParams } from './createServerlessSpyListener';
+import { PrettifyForDisplay } from './PrettifyForDisplay';
+import {
+  DynamoDBSpyHandler,
+  EventBridgeSpyHandler,
+  EventBridgeRuleSpyHandler,
+  S3SpyHandler,
+  SnsSubscriptionSpyHandler,
+  SnsTopicSpyHandler,
+  SqsSpyHandler,
+  FunctionRequestSpyHandler,
+  FunctionConsoleSpyHandler,
+  FunctionResponseSpyHandler,
+} from './SpyHandlers.ts';
+
+export type SpyListener<TSpyEvents> = {
+  [P in keyof FilterConditionally<TSpyEvents, `DynamoDB#${any}`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<DynamoDBSpyEvent>>
+    >
+  ) => DynamoDBSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `EventBridge#${any}`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<EventBridgeSpyEvent<T>>>
+    >
+  ) => EventBridgeSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `EventBridgeRule#${any}`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<EventBridgeRuleSpyEvent<T>>>
+    >
+  ) => EventBridgeRuleSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `S3#${any}`> &
+    string as `waitFor${P}`]: (
+    param?: PrettifyForDisplay<WaitForParams<PrettifyForDisplay<S3SpyEvent>>>
+  ) => S3SpyHandler;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `SnsSubscription#${any}`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<SnsSubscriptionSpyEvent<T>>>
+    >
+  ) => SnsSubscriptionSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `SnsTopic#${any}`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<SnsTopicSpyEvent<T>>>
+    >
+  ) => SnsTopicSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `Sqs#${any}`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<SqsSpyEvent<T>>>
+    >
+  ) => SqsSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `Function#${any}#Request`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<FunctionRequestSpyEvent<T>>>
+    >
+  ) => FunctionRequestSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `Function#${any}#Console`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<FunctionConsoleSpyEvent<T>>>
+    >
+  ) => FunctionConsoleSpyHandler<T>;
+} & {
+  [P in keyof FilterConditionally<TSpyEvents, `Function#${any}#Response`> &
+    string as `waitFor${P}`]: <T = any>(
+    param?: PrettifyForDisplay<
+      WaitForParams<PrettifyForDisplay<FunctionResponseSpyEvent<T>>>
+    > //      filter?: (event: FunctionResponseSpyEvent<T>) => boolean
+  ) => FunctionResponseSpyHandler<T>;
+} & {
+  stop: () => void;
+};
+
+type FilterConditionally<Source, Condition> = Pick<
+  Source,
+  {
+    [K in keyof Source]: Source[K] extends Condition ? K : never;
+  }[keyof Source]
+>;

package/listener/createServerlessSpyListener.ts

@@ -0,0 +1,258 @@
+/* eslint-disable no-prototype-builtins */
+import { Credentials } from '@aws-sdk/types';
+import { getWebSocketUrl } from 'serverless-spy-common/getWebSocketUrl';
+import { FunctionRequestSpyEvent } from 'serverless-spy-common/spyEvents/FunctionRequestSpyEvent';
+import { SpyEvent } from 'serverless-spy-common/spyEvents/SpyEvent';
+import { SpyMessage } from 'serverless-spy-common/spyEvents/SpyMessage';
+import WebSocket from 'ws';
+import { SpyListener } from './SpyListener';
+
+type ServerlessSpyListenerParams = {
+  serverlessSpyWsUrl: string;
+  credentials?: Credentials;
+};
+
+export async function createServerlessSpyListener<TSpyEvents>(
+  params: ServerlessSpyListenerParams
+) {
+  const urlSigned = await getWebSocketUrl(
+    params.serverlessSpyWsUrl,
+    params.credentials
+  );
+  const ws = new WebSocket(urlSigned);
+  const messages: SpyMessageStorage[] = [];
+  let trackers: Tracker[] = [];
+  let closed = false;
+  const functionPrefix = 'waitFor';
+
+  ws.on('open', () => {
+    console.log('connected ' + new Date().toISOString());
+  });
+  ws.on('message', (data) => {
+    console.log(`From server: ${data}`);
+
+    if (closed) return;
+    const message = JSON.parse(data.toString()) as SpyMessageStorage;
+
+    message.serviceKeyForFunction = message.serviceKey.replace(/#/g, '');
+
+    if (message.serviceKey.startsWith('Function')) {
+      message.functionContextAwsRequestId = (
+        message.data as FunctionRequestSpyEvent
+      ).context.awsRequestId;
+    }
+
+    messages.push(message);
+    resolveOldTrackerWithNewMessage(message);
+  });
+  ws.on('close', () => {
+    // console.log("disconnected " + new Date().toISOString());
+  });
+
+  const trackerMatchMessage = (
+    tracker: Tracker,
+    message: SpyMessageStorage
+  ) => {
+    if (tracker.finished) return;
+
+    if (
+      (tracker.serviceKey && tracker.serviceKey === message.serviceKey) ||
+      (tracker.serviceKeyForFunction &&
+        tracker.serviceKeyForFunction === message.serviceKeyForFunction)
+    ) {
+      if (trackerMatchCondition(tracker, message)) {
+        tracker.finished = true;
+
+        const spyAndJestMatchers: any = {
+          getData: () => message.data,
+        };
+
+        const serviceKeyForFunction = tracker.serviceKeyForFunction;
+        if (
+          serviceKeyForFunction &&
+          serviceKeyForFunction.startsWith('Function') &&
+          (serviceKeyForFunction.endsWith('Request') ||
+            serviceKeyForFunction.endsWith('Console'))
+        ) {
+          let serviceKeyForFunctionResponse = serviceKeyForFunction;
+
+          if (serviceKeyForFunctionResponse.endsWith('Request')) {
+            serviceKeyForFunctionResponse =
+              serviceKeyForFunctionResponse.substring(
+                0,
+                serviceKeyForFunctionResponse.length - 'Request'.length
+              );
+          } else if (serviceKeyForFunctionResponse.endsWith('Console')) {
+            serviceKeyForFunctionResponse =
+              serviceKeyForFunctionResponse.substring(
+                0,
+                serviceKeyForFunctionResponse.length - 'Console'.length
+              );
+          }
+
+          serviceKeyForFunctionResponse += 'Response';
+
+          spyAndJestMatchers.followedByResponse = (paramsW: WaitForParams) => {
+            return createWaitForXXXFunc(
+              serviceKeyForFunctionResponse,
+              paramsW,
+              (message.data as FunctionRequestSpyEvent).context.awsRequestId
+            )();
+          };
+        }
+
+        const proxy = new Proxy(spyAndJestMatchers, {
+          get: function (target: any, objectKey: string) {
+            if (target.hasOwnProperty(objectKey)) {
+              return target[objectKey];
+            } else if (objectKey !== 'then') {
+              return function () {
+                const jestFunctionToExecute = (expect(message.data) as any)[
+                  objectKey
+                ];
+                jestFunctionToExecute.apply(undefined, arguments);
+                return proxy;
+              };
+            }
+          },
+        });
+
+        tracker.promiseResolve(proxy);
+        return true;
+      }
+    }
+    return false;
+  };
+
+  const resolveTrackerInOldMessages = (tracker: Tracker) => {
+    for (const message of messages) {
+      if (trackerMatchMessage(tracker, message)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  const resolveOldTrackerWithNewMessage = (message: SpyMessageStorage) => {
+    for (let index = 0; index < trackers.length; index++) {
+      const tracker = trackers[index];
+      if (trackerMatchMessage(tracker, message)) {
+        trackers = trackers.splice(index, 1);
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  const spyListener = {} as SpyListener<TSpyEvents>;
+
+  spyListener.stop = () => {
+    closed = true;
+    ws.close();
+  };
+
+  const proxy = new Proxy(spyListener, {
+    get: function (target: any, objectKey: string) {
+      if (target.hasOwnProperty(objectKey)) {
+        return target[objectKey];
+      } else if (
+        typeof objectKey === 'string' &&
+        objectKey.startsWith(functionPrefix)
+      ) {
+        const paramsW = arguments[0] as WaitForParams;
+        const serviceKeyForFunction = objectKey.substring(
+          functionPrefix.length
+        );
+
+        return createWaitForXXXFunc(serviceKeyForFunction, paramsW);
+      }
+    },
+  });
+
+  return proxy as SpyListener<TSpyEvents>;
+
+  function trackerMatchCondition(tracker: Tracker, message: SpyMessageStorage) {
+    const matchCondition =
+      (tracker.condition && tracker.condition(message.data)) ||
+      !tracker.condition;
+
+    const matchRequestId =
+      (tracker.functionContextAwsRequestId &&
+        tracker.functionContextAwsRequestId ===
+          message.functionContextAwsRequestId) ||
+      !tracker.functionContextAwsRequestId;
+
+    if (tracker.functionContextAwsRequestId) {
+      console.log(
+        `${tracker.functionContextAwsRequestId} - ${message.functionContextAwsRequestId}`
+      );
+    }
+
+    return matchCondition && matchRequestId;
+  }
+
+  function createWaitForXXXFunc(
+    serviceKeyForFunction: string,
+    paramsW: WaitForParams<SpyEvent>,
+    functionContextAwsRequestId?: string
+  ) {
+    let tracker: Tracker;
+
+    const promise = new Promise((resolve, reject) => {
+      tracker = {
+        finished: false,
+        promiseResolve: resolve,
+        promiseReject: reject,
+        serviceKeyForFunction,
+        functionContextAwsRequestId,
+      };
+    });
+
+    return function waitForXXXFunc() {
+      tracker.condition = paramsW?.condition;
+
+      const timer = setTimeout(() => {
+        if (tracker.finished) return;
+        tracker.finished = true;
+        tracker.promiseReject(
+          new Error(
+            `Timeout waiting for Serverless Spy message ${serviceKeyForFunction}`
+          )
+        );
+      }, paramsW?.timoutMs || 5000);
+
+      promise.finally(() => {
+        clearTimeout(timer);
+      });
+
+      if (!resolveTrackerInOldMessages(tracker)) {
+        trackers.push(tracker);
+      }
+
+      return promise;
+    };
+  }
+}
+
+export interface WaitForParams<TSpyEvent extends SpyEvent = SpyEvent> {
+  condition?: (event: TSpyEvent) => boolean;
+  timoutMs?: number;
+}
+
+type Tracker = {
+  promiseResolve: (data: any) => void;
+  promiseReject: (data: any) => void;
+  finished: boolean;
+  serviceKey?: string;
+  serviceKeyForFunction?: string;
+  condition?: (data: any) => boolean;
+  timoutMs?: number;
+  functionContextAwsRequestId?: string;
+};
+
+type SpyMessageStorage = SpyMessage & {
+  serviceKeyForFunction: string;
+  functionContextAwsRequestId?: string;
+};

package/listener/index.ts

@@ -0,0 +1 @@
+export * from './createServerlessSpyListener';

package/listener/matchers.ts

@@ -0,0 +1,53 @@
+/*
+// import { ServerlessSpyListener } from "./ServerlessSpyListener";
+
+type CustomMatcherResult = {
+  message: () => string;
+  pass: boolean;
+};
+
+export const toReceiveEvent = async (
+  spy: any,
+  serviceKey: string,
+  condition?: (data: any) => boolean
+): Promise<CustomMatcherResult> => {
+  console.log('NOTRI');
+
+  await sleep(3000);
+
+  // console.log("SPY", spy);
+  // const events = await spy.awaitEvents((events) => {
+  //   return events.some((event) => event["detail-type"] === expected);
+  // });
+
+  // const pass = events.some((event) => event["detail-type"] === expected);
+
+  // const message = pass
+  //   ? () => {
+  //       return (
+  //         matcherHint("toHaveEventWithDetailType", "eventsSpy", "detail-type") +
+  //         "\n\n" +
+  //         `Expected: not ${printExpected(expected)}\n` +
+  //         `Number of events: ${printReceived(events.length)}`
+  //       );
+  //     }
+  //   : () => {
+  //       return (
+  //         matcherHint("toHaveEventWithDetailType", "eventsSpy", "detail-type") +
+  //         "\n\n" +
+  //         `Expected: ${printExpected(expected)}\n` +
+  //         (events.length > 0
+  //           ? `Received: ${printReceived(events[0]?.["detail-type"])}`
+  //           : `Number of events: ${printReceived(events.length)}`)
+  //       );
+  //     };
+
+  return { message: () => 'OK', pass: true };
+};
+
+function sleep(ms: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+*/

package/listener/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "serverless-spy-listener",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "ws": "^8.8.1",
+    "serverless-spy-common": "*",
+    "@aws-sdk/types": "^3.127.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.3"
+  }
+}

package/listener/setup.ts

@@ -0,0 +1,21 @@
+// import * as matchers from './matchers';
+
+// if (expect !== undefined) {
+//   expect.extend(matchers);
+// } else {
+//   /* eslint-disable no-console */
+//   console.error(
+//     "Unable to find Jest's global expect." +
+//       '\nPlease check you have added jest-extended correctly to your jest configuration.' +
+//       '\nSee https://github.com/jest-community/jest-extended#setup for help.'
+//   );
+//   /* eslint-enable no-console */
+// }
+
+// declare global {
+//   namespace jest {
+//     interface Matchers<R> {
+//       toReceiveEvent(serviceKey: string, condition?: (data: any) => boolean): R;
+//     }
+//   }
+// }

package/listener/tsconfig.dev.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Node 16",
+  "compilerOptions": {
+    "lib": ["es2021"],
+    "module": "esnext",
+    "target": "es2021",
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  }
+}

package/listener/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Node 16",
+  "compilerOptions": {
+    "lib": ["es2021"],
+    "module": "esnext",
+    "target": "es2021",
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  }
+}

package/package.json

@@ -0,0 +1,132 @@
+{
+  "name": "serverless-spy",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:ServerlessLife/serverless-spy.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:update": "npx projen test:update",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Marko (ServerlessLife.com)",
+    "email": "marko@serverlesslife.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@types/jest": "^27",
+    "@types/node": "^14",
+    "@typescript-eslint/eslint-plugin": "^5",
+    "@typescript-eslint/parser": "^5",
+    "aws-cdk-lib": "2.37.1",
+    "constructs": "10.0.5",
+    "eslint": "^8",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-import-resolver-node": "^0.3.6",
+    "eslint-import-resolver-typescript": "^3.4.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^27",
+    "jest-junit": "^13",
+    "jsii": "^1.63.2",
+    "jsii-diff": "^1.63.2",
+    "jsii-docgen": "^7.0.67",
+    "jsii-pacmak": "^1.63.2",
+    "json-schema": "^0.4.0",
+    "npm-check-updates": "^15",
+    "prettier": "^2.7.1",
+    "projen": "^0.61.7",
+    "standard-version": "^9",
+    "ts-jest": "^27",
+    "typescript": "^4.7.4"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.37.1",
+    "constructs": "^10.0.5"
+  },
+  "dependencies": {
+    "@aws-cdk/aws-apigatewayv2-alpha": "2.37.1-alpha.0",
+    "@aws-cdk/aws-apigatewayv2-integrations-alpha": "2.37.1-alpha.0"
+  },
+  "keywords": [
+    "cdk"
+  ],
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "version": "0.0.0",
+  "jest": {
+    "testMatch": [
+      "<rootDir>/src/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/(test|src)/**/*(*.)@(spec|test).ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "preset": "ts-jest",
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.dev.json"
+      }
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "overrides": {
+    "@types/prettier": "2.6.0"
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"npx projen\"."
+}