keploy
diff --git a/‎.gitignore
Lines changed: 1 addition & 1 deletion b/‎.gitignore
Lines changed: 1 addition & 1 deletion
diff --git a/‎README.md
Lines changed: 78 additions & 3 deletions b/‎README.md
Lines changed: 78 additions & 3 deletions
diff --git a/‎integrations/express/middleware.ts
Lines changed: 58 additions & 86 deletions b/‎integrations/express/middleware.ts
Lines changed: 58 additions & 86 deletions
diff --git a/‎integrations/express/register.ts
Lines changed: 1 addition & 1 deletion b/‎integrations/express/register.ts
Lines changed: 1 addition & 1 deletion
@@ -184,4 +184,4 @@ node_modules
 
 # Build files
 
-dist
+dist
@@ -29,14 +29,30 @@ npm i https://github.com/keploy/typescript-sdk
 ```js
 require("typescript-sdk/dist/integrations/express/register");
 ```
+The require statement should be at the top of your main file (server.js). 
+
+Example :
+```js
+require("typescript-sdk/dist/integrations/express/register");
+var express = require('express');
+var app = express();
+app.get('/', function (req, res) {
+    res.send('Hello World!\n');
+});
+
+var server = app.listen(3000,() =>
+console.log(`Example app listening on port 3000!`));
+module.exports = server;
+```
+
 ## Configure
 ```
 export KEPLOY_MODE="test"
 export KEPLOY_APP_NAME="my-app"
 export KEPLOY_APP_HOST="localhost"
 export KEPLOY_APP_PORT=5050 # port on which server is running
 export KEPLOY_APP_DELAY=5 # time delay before starting testruns(in seconds)
-export KEPLOY_APP_TIMEOUT=100 # should be number
+export KEPLOY_APP_TIMEOUT=100 # should be number 
 # export KEPLOY_APP_FILTER={"urlRegex":"*"}  # should be json not to capture for certain url's
 
 export KEPLOY_SERVER_URL="http://localhost:8081/api" # self hosted keploy running server
@@ -50,11 +66,22 @@ There are 3 modes:
 
 **Note:** `KEPLOY_MODE` value is case sensitive.
 
-## Supported Frameworks
+## Generate E2E tests (with mocks)
+
+```
+export KEPLOY_TEST_CASE_PATH="./example"    # If KEPLOY_TEST_CASE_PATH is not provided then a folder named keploy-tests will be made containing mocks folder. If KEPLOY_MOCK_PATH is provided then the mocks will be generated there. 
+export KEPLOY_MOCK_PATH="./exampleMockPath"
+```
+
+**Note:** To enable `Test Export`, add `export ENABLE_TEST_EXPORT=true` in your .env file of [keploy-server](https://github.com/keploy/keploy) repository. If enabled, yaml files  containing test cases will be generated in the directory provided by the user. Similarly, mocks will be generated in the yaml files.
+
+## Supported Routers
 ### 1. Express
 ```js
 require("typescript-sdk/dist/integrations/express/register");
 ```
+The require statement should be at the top of your main file (server.js).
+
 #### Example
 ```js
 require("typescript-sdk/dist/integrations/express/register");
@@ -72,6 +99,18 @@ app.listen(port, () => {
     console.log(`Server is running on port: ${port}`);
 })
 ```
+Note:- Import statements can't be used. Use require instead of import.
+
+## Supported Dependencies
+
+### 1. Octokit
+
+```js
+require("typescript-sdk/dist/integrations/octokit/require")
+```
+These statements should be at the top of your main file (server.js).
+
+Note:- Import statements can't be used. Only CommonJs support is currently provided.
 ## Development Setup
 
 - This project uses [Yarn](https://yarnpkg.com/) for package management. To install yarn, please make sure [Node](https://nodejs.org/en/) is installed and then:
@@ -86,6 +125,40 @@ npm i -g yarn
 yarn install
 ```
 
+### How to use mock library
+
+The external calls from unit tests will be recorded and replayed as mocks from yaml files under a directory named mocks.
+
+Following is an example of unit test with octokit :
+
+#### Example
+```js
+require("typescript-sdk/dist/integrations/octokit/require")
+var {NewContext} = require ("typescript-sdk/dist/mock/mock")
+var assert = require('assert');
+const { Octokit, App } = require("octokit");
+describe('routes', function () {
+    var server, octokit;
+    beforeEach(function () {
+        NewContext({Mode: "record", Name: "your demo app name"})  // Set your keploy mode and name here.
+        // Clears the cache so a new server instance is used for each test.
+        // delete require.cache[require.resolve('../app')];
+
+        octokit = new Octokit({ auth: "your authentication token"});
+
+    });
+    // Test to make sure URLs respond correctly.
+    it("url/", async function () {
+        return new Promise(function(resolve){
+            octokit.rest.users.getAuthenticated({}).then((result) => {
+                assert.equal(result.data.login, "your github username")
+                resolve()    
+            });
+        })
+    });
+});
+```
+
 ### Integration with Mocha testing framework
 You just need to do some imports and call a built-in assert function in your code in your unit test file and that's it!!🔥🔥🔥
 ```js
@@ -99,7 +172,7 @@ describe("test function", ()=>{
             done()
           })
     test("should be running", async ()=> {
-      await keploy.assertTests();
+      return keploy.assertTests();
     });
     after(()=>{
          process.exit(1); //exits the node server
@@ -108,6 +181,8 @@ describe("test function", ()=>{
 ```
 Note:- To see code coverage please use nyc mocha and see how many lines are covered!!
 
+Note:- Jest is not supported currently!!
+
 
 - Furthermore, to commit your changes use `yarn commit` instead of `git commit` for better commit experience.
 
 
@@ -1,98 +1,62 @@
 import express from "express";
 import Keploy from "../../src/keploy";
 import { Request, Response, NextFunction } from "express";
-import http = require("http");
-
-type Dependency = {
-  name: string;
-  type: string;
-  meta: object;
-  data: object[];
-};
-
-type KeployContext = {
-  mode: string | undefined;
-  testId: string | undefined;
-  deps: Dependency[] | undefined;
-};
-
-class Context {
-  static _bindings = new WeakMap<Request, Context>();
-  static _response = new WeakMap<Request, Context>();
-
-  public keployContext: KeployContext;
-  public responseBody: object[];
-
-  constructor(mode?: string, testId?: string, deps?: Dependency[]) {
-    this.keployContext = {
-      mode,
-      testId,
-      deps,
-    };
-    this.responseBody = [];
-  }
-  // bind sets an empty Context for req as a key in _bindings.
-  static bind(req: Request): void {
-    const ctx = new Context();
-    Context._bindings.set(req, ctx);
-  }
-  // get returns the value of Context stored for the req key. It returns null if req key is not present
-  static get(req: Request): Context | null {
-    return Context._bindings.get(req) || null;
-  }
-  // set is used to make a key-value pair for the  req and ctx
-  static set(req: Request, ctx: Context): void {
-    Context._bindings.set(req, ctx);
-    Context._response.set(req, ctx);
+import { createExecutionContext, getExecutionContext } from "../../src/context";
+import { StrArr } from "../../proto/services/StrArr";
+
+class ResponseBody {
+  static responseMap = new WeakMap<Request, ResponseBody>();
+
+  public body: object[];
+
+  constructor() {
+    this.body = [];
   }
 
-  static pushResponse(req: Request, chunks: object): void {
-    const ctx = Context._response.get(req);
-    const oldResponse = ctx?.responseBody;
-    if (oldResponse === undefined || ctx == undefined) {
+  static push(req: Request, chunks: object): void {
+    const resp = ResponseBody.responseMap.get(req);
+    if (resp === undefined || resp.body === undefined) {
+      const resp = new ResponseBody();
+      resp.body = [chunks];
+      ResponseBody.responseMap.set(req, resp);
+
       return;
     }
-    oldResponse.push(chunks);
-    Context._response.set(req, ctx);
+    resp.body.push(chunks);
+    ResponseBody.responseMap.set(req, resp);
   }
-  static getResponse(req: Request): object[] | undefined {
-    const ctx = Context._response.get(req);
-    return ctx?.responseBody;
+  static get(req: Request): object[] | undefined {
+    const ctx = ResponseBody.responseMap.get(req);
+    return ctx?.body;
   }
 }
 
 // got package identifies header fields to identify request and response therefore, request headers
 // should not contain header fields (like: content-length, connection)
-export function getRequestHeader(headers: http.IncomingHttpHeaders) {
-  const result: { [key: string]: string[] } = {};
+export function getRequestHeader(headers: any) {
+  const result: { [key: string]: StrArr } = {};
   for (const key in headers) {
     let val = new Array<string>();
-    if (
-      key.toLowerCase() === "content-length" ||
-      key.toLowerCase() === "connection"
-    ) {
-      continue;
-    }
     if (typeof headers[key] === typeof "s") {
       val.push(headers[key] as string);
     } else if (typeof headers[key] === typeof ["s"]) {
       val = headers[key] as string[];
     }
-    result[key] = val;
+    result[key] = { Value: val };
   }
   return result;
 }
 
-export function getResponseHeader(header: http.OutgoingHttpHeaders) {
-  const result: { [key: string]: string[] } = {};
+export function getResponseHeader(header: any) {
+  const result: { [key: string]: StrArr } = {};
   for (const key in header) {
     let val = new Array<string>();
     if (typeof header[key] === typeof "s" || typeof header[key] === typeof 1) {
       val.push(header[key] as string);
     } else if (typeof header[key] === typeof ["s"]) {
       val = header[key] as string[];
     }
-    result[key] = val;
+    result[key] = { Value: val };
   }
   return result;
 }
@@ -110,22 +74,26 @@ export default function middleware(
         process.env.KEPLOY_MODE == "off") ||
       keploy == undefined
     ) {
+      createExecutionContext({ mode: "off" });
       next();
       return;
     }
 
     const id = req.get("KEPLOY_TEST_ID");
     // test mode
     if (id != undefined && id != "") {
-      const ctx = new Context("test", id, []);
-      Context.set(req, ctx);
+      createExecutionContext({
+        mode: "test",
+        testId: id,
+        deps: keploy.getDependencies(id),
+        mocks: keploy.getMocks(id),
+      });
       captureResp(req, res, next);
       return;
     }
 
     // record mode
-    const ctx = new Context("record");
-    Context.set(req, ctx);
+    createExecutionContext({ mode: "record", deps: [], mocks: [] });
     captureResp(req, res, next);
   };
 }
@@ -138,7 +106,7 @@ function captureResp(
   const oldSend = res.send;
 
   res.send = (chunk: object) => {
-    Context.pushResponse(req, chunk);
+    ResponseBody.push(req, chunk);
     return oldSend.apply(res, [chunk]);
   };
 
@@ -157,44 +125,48 @@ export function afterMiddleware(keploy: Keploy, req: Request, res: Response) {
 
   const id = req.get("KEPLOY_TEST_ID");
   if (id !== undefined && id !== "") {
-    const respHeader: { [key: string]: string[] } = getResponseHeader(
+    const respHeader: { [key: string]: StrArr } = getResponseHeader(
       res.getHeaders()
     );
     const resp = {
       status_code: res.statusCode,
       header: respHeader,
       // @ts-ignore
-      body: String(Context.getResponse(req)),
+      body: String(ResponseBody.get(req)),
     };
     keploy.putResp(id, resp);
     return;
   }
 
   // req.headers
-  const reqHeader: { [key: string]: string[] } = getRequestHeader(req.headers);
+  const reqHeader: { [key: string]: StrArr } = getRequestHeader(req.headers);
 
   // response headers
-  const respHeader: { [key: string]: string[] } = getResponseHeader(
+  const respHeader: { [key: string]: StrArr } = getResponseHeader(
     res.getHeaders()
   );
 
   keploy.capture({
-    captured: Date.now(),
-    appId: keploy.appConfig.name,
+    Captured: Date.now(),
+    AppID: keploy.appConfig.name,
     // change url to uri ex: /url-shortner/:param
-    uri: req.originalUrl,
-    httpReq: {
-      method: req.method,
-      url: req.originalUrl,
-      url_params: req.params,
-      header: reqHeader,
-      body: JSON.stringify(req.body),
+    URI: req.originalUrl,
+    HttpReq: {
+      Method: req.method,
+      URL: req.originalUrl,
+      URLParams: req.params,
+      Header: reqHeader,
+      Body: JSON.stringify(req.body),
     },
-    httpResp: {
-      status_code: res.statusCode,
-      header: respHeader,
+    HttpResp: {
+      StatusCode: res.statusCode,
+      Header: respHeader,
       // @ts-ignore
-      body: String(Context.getResponse(req)),
+      Body: String(ResponseBody.get(req)),
     },
+    Dependency: getExecutionContext().context.deps,
+    TestCasePath: keploy.appConfig.testCasePath,
+    MockPath: keploy.appConfig.mockPath,
+    Mocks: getExecutionContext().context.mocks,
   });
 }
@@ -17,7 +17,7 @@ Hook(["express"], function (exports) {
     keployApp.use(cors());
     keployApp.use(expressMiddleware(keploy));
     keployApp.appliedMiddleware = true;
-    keploy.create();
+    keploy.runTests();
     return keployApp;
   }
Original file line number	Diff line number	Diff line change
`@@ -184,4 +184,4 @@ node_modules`
`184`	`184`
`185`	`185`	`# Build files`
`186`	`186`
`187`		`-dist`
	`187`	`+dist`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ Hook(["express"], function (exports) {`
`17`	`17`	`keployApp.use(cors());`
`18`	`18`	`keployApp.use(expressMiddleware(keploy));`
`19`	`19`	`keployApp.appliedMiddleware = true;`
`20`		`- keploy.create();`
	`20`	`+ keploy.runTests();`
`21`	`21`	`return keployApp;`
`22`	`22`	`}`
`23`	`23`