Repository: pactumjs/pactum
Pull request #41 (2021-01-03 11:47:53)

3.0.3
- afterInteraction
- **POST** /pactum/reporter/end
- moved docs to its own site


Patch:
diff --git a/README.md b/README.md
index 52681c2..7eb46ce 100644
--- a/README.md
+++ b/README.md
@@ -1,25 +1,28 @@
 # pactum
 
-![Build](https://github.com/ASaiAnudeep/pactum/workflows/Build/badge.svg?branch=master)
+![Build](https://github.com/pactumjs/pactum/workflows/Build/badge.svg?branch=master)
 ![Coverage](https://img.shields.io/codeclimate/coverage/ASaiAnudeep/pactum)
 ![Downloads](https://img.shields.io/npm/dt/pactum)
 ![Size](https://img.shields.io/bundlephobia/minzip/pactum)
 ![Platform](https://img.shields.io/node/v/pactum)
 
-**pactum** is a REST API Testing Tool used to write e2e, integration, contract & component (*or service level*) tests. It comes with a powerful *mock server* which can control the state of external dependencies & combines the implementation of a consumer-driven contract library [Pact](https://docs.pact.io) for JavaScript.
+**pactum** is a REST API Testing Tool used to automate e2e, integration, contract & component (*or service level*) tests. It comes with a powerful *mock server* which can control the state of external dependencies.
 
-#### *Why pactum?*
-
-- Lightweight.
-- Simple & Powerful.
-- Extendable & Customizable.
-- Clear & Comprehensive Testing Style.
-- Component, Contract & E2E testing of APIs.
+- 🐦 Lightweight
+- 🚀 Simple & Powerful
+- 🔧 Extendable & Customizable
+- 📚 Clear & Comprehensive Testing Style
+- 🔗 Component, Contract & E2E testing of APIs
 
 ## Documentation
 
-This readme offers an basic introduction to the library. Head over to the full [documentation](https://asaianudeep.github.io/pactum) for getting started.
+This readme offers an basic introduction to the library. Head over to the full documentation at https://pactumjs.github.io
 
+- [API Testing](https://pactumjs.github.io/#/api-testing)
+- [Integration Testing](https://pactumjs.github.io/#/integration-testing)
+- [Component Testing](https://pactumjs.github.io/#/component-testing)
+- [Contract Testing](https://pactumjs.github.io/#/contract-testing)
+- [E2E Testing](https://pactumjs.github.io/#/e2e-testing)
 
 ## Installation
 
@@ -74,7 +77,7 @@ mocha /path/to/test
 
 #### Using Cucumber
 
-See [pactum-cucumber-boilerplate](https://github.com/ASaiAnudeep/pactum-cucumber-boilerplate) for more details on pactum & cucumber integration.
+See [pactum-cucumber-boilerplate](https://github.com/pactumjs/pactum-cucumber-boilerplate) for more details on pactum & cucumber integration.
 
 ```javascript
 // steps.js
@@ -105,198 +108,25 @@ Scenario: Check TeaPot
   Then response should have a status 200
 ```
 
-### Complex HTTP Assertions
-
-It allows verification of returned status codes, headers, body, json objects, json schemas & response times.
-
-Running complex test expectations.
-
-```javascript
-it('should have a user with id', () => {
-  return pactum.spec()
-    .get('/api/users/1')
-    .expectStatus(201)
-    .expectHeaderContains('content-type', 'application/json')
-    // performs partial deep equal
-    .expectJsonLike([
-      {
-        "id": /\d+/,
-        "name": "Bolt",
-        "address": [
-          {
-            "city": "NewYork"
-          }
-        ]
-      }
-    ])
-    .expectJsonSchema({
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          id: {
-            type: 'number'
-          }
-        }
-      }
-    })
-    .expectJsonLikeAt('[0].address[*].city', ['Boston', 'NewYork'])
-    .expectResponseTime(100);
-});
-```
-
-It also allows us to break assertions into multiple steps that makes our expectations much more clearer.
-
-```javascript
-const pactum = require('pactum');
-
-describe('Chai Like Assertions', () => {
-
-  let spec = pactum.spec();
-  let response;
-
-  it('given a user is requested', () => {
-    spec.get('http://localhost:9393/api/users/snow');
-  });
-
-  it('should return a response', async () => {
-    response = await spec.toss();
-  });
-
-  it('should return a status 200', () => {
-    spec.response().to.have.status(200);
-  });
-
-  it('should return a valid user', async () => {
-    spec.response().to.have.json({ name: 'snow'});
-  });
-
-});
-```
- 
-Learn more about building requests & validating responses with **pactum** at [API Testing](https://asaianudeep.github.io/pactum/#/api-testing)
-
-## Integration Testing
-
-Integration Testing is defined as a type of testing where software modules or components are logically integrated & tested.
-
-API Integration Testing has many aspects but usually involves passing data between tests or waiting for some action to be reflected in the system.
-
-### Nested Dependent HTTP Calls
-
-```javascript
-const pactum = require('pactum');
-
-it('should return all posts and first post should have comments', async () => {
-  const postID = await pactum.spec()
-    .get('http://jsonplaceholder.typicode.com/posts')
-    .expectStatus(200)
-    .returns('[0].id');
-  await pactum.spec()
-    .get(`http://jsonplaceholder.typicode.com/posts/${postID}/comments`)
-    .expectStatus(200);
-});
-```
-
-```javascript
-it('create new user', async () => {
-  await pactum.spec()
-    .post('/api/users')
-    .withJson(/* user details */)
-    .expectStatus(200)
-    .stores('UserID', 'id'); // if response body = { id: 'C001019' }
-});
-
-it('validate new user details', async () => {
-  await pactum.spec()
-    .get('/api/users')
-    .withQueryParams('id', '@DATA:STR::UserId@')
-    .expectStatus(200);
-});
-```
-
-### Retry Mechanism
-
-```javascript
-await pactum.spec()
-  .get('/some/async/operation')
-  .retry({
-    count: 2,
-    delay: 2000,
-    strategy: ({res}) => { return res.statusCode === 202 }
-  })
-  .expectStatus(200);
-```
-
-Learn more about these features at [Integration Testing](https://asaianudeep.github.io/pactum/#/integration-testing)
-
-## e2e Testing
-
-End-To-End testing is a software testing method that validates entire software from starting to end along with its integration with external interfaces.
-
-Pactum allows to
-
-* Share Context
-* Set Up & Tear Down
-* Reuse Specs
-
-```javascript
-const pactum = require('pactum');
-
-describe('user should be able to create an order', () => {
-
-  const test = pactum.e2e('AddNewOrder');
-
-  it('create an order', async () => {
-    await test
-      .step('CreateOrder') // unique name for the step
-      .spec('post order') // spec to run
-      .clean('delete order'); // clean up to run at the end
-  });
-
-  it('update the created order', async () => {
-    await test
-      .step('UpdateOrder') // unique name for the step
-      .spec('update order'); // spec to run
-  });
-
-  it('get created order', async () => {
-    await test
-      .step('GetOrder') // unique name for the step
-      .spec('get order'); // spec to run
-  });
-
-  it('clean up', async () => {
-    await test.cleanup(); // runs all registered clean up specs in LIFO order
-  });
-
-});
-```
-
-Learn more about these features at [E2E Testing](https://asaianudeep.github.io/pactum/#/e2e-testing)
-
-
 ## Mock Server
 
-Mock Server allows you to mock any server or service via HTTP or HTTPS, such as a REST endpoint. Simply it is a simulator for HTTP-based APIs.
-
-**pactum** can act as a standalone *mock server* or as a *service virtualization* tool. It comes with a **powerful request & response matching** and out of the box **Data Management**.
+**pactum** can act as a standalone *mock server* that allows us to mock any server via HTTP or HTTPS, such as a REST endpoint. Simply it is a simulator for HTTP-based APIs.
 
 Running **pactum** as a standalone *mock server*.
 
 ```javascript
-const pactum = require('pactum');
+const { mock } = require('pactum');
 const { regex } = require('pactum-matchers');
 
-pactum.mock.addInteraction({
-  withRequest: {
+mock.addInteraction({
+  request: {
     method: 'GET',
     path: '/api/projects',
-    query: {
+    queryParams: {
       date: regex('2020-12-12', /^\d{4}-\d{2}-\d{2}$/)
     }
   },
-  willRespondWith: {
+  response: {
     status: 200,
     headers: {
       'content-type': 'application/json'
@@ -308,147 +138,9 @@ pactum.mock.addInteraction({
   }
 });
 
-pactum.mock.start(3000);
-```
-
-Learn more about **pactum** as a *mock server* at [Mock Server](https://asaianudeep.github.io/pactum/#/mock-server)
-
-
-## Component Testing
-
-Component testing is defined as a software testing type, in which the testing is performed on each component separately without integrating with other components. So the service under test might be talking to a mock server, instead of talking to real external services.
-
-**Pactum** comes with a mock server where you will able to control the behavior of each external service. Interactions are a way to instruct the mock server to simulate the behavior of external services.
-
-Running a component test expectation with mocking an external dependency.
-
-```javascript
-const pactum = require('pactum');
-
-before(() => {
-  // starts a mock server on port 3000
-  return pactum.mock.start(3000);
-});
-
-it('should get jon snow details', () => {
-  return pactum.spec()
-    // adds interaction to mock server & removes it after the spec
-    .useMockInteraction({
-      withRequest: {
-        method: 'GET',
-        path: '/api/address/4'
-      },
-      willRespondWith: {
-        status: 200,
-        body: {
-          city: 'WinterFell',
-          country: 'The North'
-        }
-      } 
-    })
-    .get('http://localhost:3333/users/4')
-    .expectStatus(200)
-    .expectJson({
-      id: 4,
-      name: 'Jon Snow',
-      address: {
-        city: 'WinterFell',
-        country: 'The North'
-      }
-    });
-});
-
-after(() => {
-  return pactum.mock.stop();
-});
+mock.start(3000);
 ```
 
-Learn more about component testing with **pactum** at [Component Testing](https://asaianudeep.github.io/pactum/#/component-testing)
-
-## Contract Testing
-
-Contract Testing is a technique for testing interactions between applications (often called as services) that communicate with each other, to ensure the messages they send or receive conform to a shared understanding that is documented in a **contract**.
-
-Learn more about contract testing at [pact.io](https://docs.pact.io)
-
-Learn more about contract testing with **pactum** at [Contract Testing](https://asaianudeep.github.io/pactum/#/contract-testing)
-
-[![Contract Testing](https://img.youtube.com/vi/-6x6XBDf9sQ/0.jpg)](https://www.youtube.com/watch?v=-6x6XBDf9sQ)
-
-Contract Testing has two steps
-
-1. Defining Consumer Expectations (**Consumer Testing**)
-2. Verifying Expectations on Provider (**Provider Verification**)
-
-### Consumer Testing
-
-Running a consumer test with the help of a *mock server* & a single pact interaction. 
-If the pact interaction is not exercised, the test will fail.
-
-```javascript
-const pactum = require('pactum');
-const mock = pactum.mock;
-const consumer = pactum.consumer;
-
-before(async () => {
-  consumer.setConsumerName('consumer-service');
-  await mock.start();
-});
-
-it('GET - one interaction', async () => {
-  await pactum.spec()
-    .usePactInteraction({
-      provider: 'projects-service',
-      state: 'when there is a project with id 1',
-      uponReceiving: 'a request for project 1',
-      withRequest: {
-        method: 'GET',
-        path: '/api/projects/1'
-      },
-      willRespondWith: {
-        status: 200,
-        headers: {
-          'content-type': 'application/json'
-        },
-        body: {
-          id: 1,
-          name: 'fake'
-        }
-      }
-    })
-    .get('http://localhost:9393/api/projects/1')
-    .expectStatus(200)
-    .expectJsonLike({
-      id: 1,
-      name: 'fake'
-    });
-});
-
-after(async () => {
-  await mock.stop();
-  await consumer.publish(/* publish options */);
-});
-```
-
-Learn more about **pactum** as a consumer tester at [Consumer Testing](https://asaianudeep.github.io/pactum/#/consumer-testing)
-
-### Provider Verification
-
-Running a provider verification test with the help of a [pact broker](https://github.com/pact-foundation/pact_broker). 
-
-```javascript
-await pactum.provider.validate({
-  pactBrokerUrl: 'http://pact-broker:9393',
-  providerBaseUrl: 'http://user-service:3000',
-  provider: 'user-service',
-  providerVersion: '1.2.3'
-});
-```
-
-Learn more about **pactum** as a provider verifier at [Provider Verification](https://asaianudeep.github.io/pactum/#/provider-verification)
-
-
-
 # Notes
 
 Inspired from [frisby](https://docs.frisbyjs.com/) testing style & [pact](https://docs.pact.io) interactions.
\ No newline at end of file
diff --git a/docs/.nojekyll b/docs/.nojekyll
deleted file mode 100644
index e69de29..0000000
diff --git a/docs/_coverpage.md b/docs/_coverpage.md
deleted file mode 100644
index 180db36..0000000
--- a/docs/_coverpage.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# <span style="letter-spacing: 2px;">**PACTUM**</span><span style="font-weight: bold; color: yellow; background-color: black; padding-left: 10px; padding-right: 10px">JS<span> <small style="margin-left: 15px">3.0.2</small>
-
-> Free & Open Source REST API Testing Tool for all levels in a **Test Pyramid**
-
-- 🐦 Lightweight
-- 🚀 Simple & Powerful
-- 🔧 Extendable & Customizable
-- 📚 Clear & Comprehensive Testing Style
-- 🔗 Component, Contract & E2E testing of APIs
-
-<a href="#pactum">Get Started</a>
-
-![color](#f0f0f0)
\ No newline at end of file
diff --git a/docs/_navbar.md b/docs/_navbar.md
deleted file mode 100644
index 1ea007b..0000000
--- a/docs/_navbar.md
+++ /dev/null
@@ -1,13 +0,0 @@
-- **Tutorials**
-  - [Quick Start](quick-start.md)
-  - [Test Runners](test-runners.md)
-  - [API Testing](api-testing.md)
-  - [Integration Testing](integration-testing.md)
-  - [E2E Testing](e2e-testing.md)
-  - [Mock Server](mock-server.md)
-  - [Component Testing](component-testing.md)
-  - [Contract Testing](contract-testing.md)
-  - [Data Management](data-management.md)
-  - [Matching](matching.md)
-  - [Reporting](reporting.md)
-  - [Fuzz Testing](fuzz-testing.md)
\ No newline at end of file
diff --git a/docs/data-management.md b/docs/data-management.md
deleted file mode 100644
index 1293a07..0000000
--- a/docs/data-management.md
+++ /dev/null
@@ -1,343 +0,0 @@
-# Data Management
-
-Data Management is one of the most powerful features of **pactum**. It saves time by allowing us to reuse common data.
-
-## Introduction
-
-As the functionality of the application grows, the scope of the testing grows with it. At one point, managing data becomes complex.
-
-Assume you have numerous test cases around adding a new user to your system. To add a new user you post the following JSON to `/api/users` endpoint.
-
-```json
-{
-  "FirstName": "Jon",
-  "LastName": "Snow",
-  "Age": 26,
-  "House": "Castle Black"
-}
-```
-
-Now let's assume, your application no longer accepts the above JSON. It needs a new field `Gender` in the JSON. It will be tedious to update all your existing test cases to add the new field.
-
-```json
-{
-  "FirstName": "Jon",
-  "LastName": "Snow",
-  "Age": 26,
-  "Gender": "male",
-  "House": "Castle Black"
-}
-```
-
-To solve these kind of problems, **pactum** comes with a concept of *Data Templates* & *Data References* to manage your test data. It helps us to re-use data across tests.
-
-## Data Template
-
-A Data Template is a standard format for a particular resource. Once a template is defined, it can be used across all the tests to perform a request.
-
-Use `stash.addDataTemplate` to add a data template. To use the template in the tests, use `@DATA:TEMPLATE@` as key & the name of the template as value.
-
-<!-- tabs:start -->
-
-#### ** base.spec.js **
-
-```js
-const pactum = require('pactum');
-const stash = pactum.stash;
-
-before(() => {
-  stash.addDataTemplate({
-    'User:New': {
-      "FirstName": "Jon",
-      "LastName": "Snow",
-      "Age": 26,
-      "Gender": "male",
-      "House": "Castle Black"
-    }
-  });
-});
-```
-
-#### ** users.spec.js **
-
-```javascript
-const pactum = require('pactum');
-
-it('adds a new user', async () => {
-  await pactum.spec()
-    .post('/api/users')
-    .withJson({
-      '@DATA:TEMPLATE@': 'User:New'
-    })
-    .expectStatus(200);
-    /*
-      The value of the template will be posted to /api/users
-      {
-        "FirstName": "Jon",
-        "LastName": "Snow",
-        "Age": 26,
-        "Gender": "male",
-        "House": "Castle Black"
-      }
-    */
-});
-```
-
-<!-- tabs:end -->
-
-The exact resource is not going to be used across every test. Every test might need specific values. This library supports the overriding of specific values & extending the data template. This allows tests to be customized as much as you'd like when using templates.
-
-```javascript
-it('should not add a user with negative age', async () => {
-  await pactum.spec()
-    .post('/api/users')
-    .withJson({
-      '@DATA:TEMPLATE@': 'User:New',
-      '@OVERRIDES@': {
-        'Age': -1,
-        'House': 'WinterFell'
-      }
-    })
-    .expectStatus(400);
-    /*
-      The value of the template with overridden values will be posted to /api/users
-      {
-        "FirstName": "Jon",
-        "LastName": "Snow",
-        "Age": -1,
-        "Gender": "male",
-        "House": "WinterFell"
-      }
-    */
-});
-```
-
-!> Templates can also reference other templates. *Be cautious not to create circular dependencies*
-
-<!-- tabs:start -->
-
-#### ** base.spec.js **
-
-```js
-const pactum = require('pactum');
-const stash = pactum.stash;
-
-before(() => {
-  stash.addDataTemplate({
-    'User:New': {
-      "FirstName": "Jon",
-      "LastName": "Snow",
-      "Age": 26,
-      "Gender": "male",
-      "House": "Castle Black"
-    },
-    'User:New:WithEmptyAddress': {
-      '@DATA:TEMPLATE@': 'User:New',
-      '@OVERRIDES@': {
-        'Address': []
-      }
-    },
-    'User:New:WithAddress': {
-      '@DATA:TEMPLATE@': 'User:New',
-      '@OVERRIDES@': {
-        'Address': [
-          {
-            '@DATA:TEMPLATE@': 'Address:New'
-          }
-        ]
-      }
-    },
-    'Address:New': {
-      'Street': 'Kings Road',
-      'Country': 'WestRos'
-    }
-  });
-});
-```
-
-#### ** users.spec.js **
-
-```js
-const pactum = require('pactum');
-
-it('should add a user with address', async () => {
-  await pactum.spec()
-    .post('/api/users')
-    .withJson({
-      '@DATA:TEMPLATE@': 'User:WithAddress',
-      '@OVERRIDES@': {
-        'Age': 36,
-        'Address': [
-          {
-            'Country': 'Beyond The Wall',
-            'Zip': 524004
-          }
-        ]
-      }
-    })
-    .expectStatus(400);
-    /*
-      The value of the template with overridden values will be posted to /api/users
-      {
-        "FirstName": "Jon",
-        "LastName": "Snow",
-        "Age": 36,
-        "Gender": "male",
-        "House": "WinterFell",
-        "Address": [
-          {
-            'Street': 'Kings Road',
-            'Country': 'Beyond The Wall',
-            'Zip': 524004       
-          }
-        ]
-      }
-    */
-});
-```
-
-<!-- tabs:end -->
-
-## Data References
-
-### Data Map
-
-A Data Map is a collection of data that can be referenced in data templates or tests. The major differences between a data template & a data map are
-
-* When a data template is used, the current object will be replaced.
-* When a data map is used, the current object's property value will be replaced.
-
-Use `stash.addDataMap` to add a data map. To use the map in the tests or in the template, use `$M{<json-query>}` as the value.
-
-```javascript
-const pactum = require('pactum');
-const stash = pactum.stash;
-
-before(() => {
-  stash.addDataMap({
-    'User': {
-      'FirstName': 'Jon',
-      'LastName': 'Snow',
-      'Country': 'North'
-    }
-  });
-  stash.addDataTemplate({
-    'User:New': {
-      "FirstName": "$M{User.FirstName}",
-      "LastName": "$M{User.LastName}",
-      "FullName": "$M{User.FirstName} $M{User.LastName}",
-      "Age": 26,
-      "Gender": "male",
-      "House": "Castle Black"
-    }
-  });
-});
-
-/*
-  The template `User:New` will be 
-  {
-    "FirstName": "Jon",
-    "LastName": "Snow",
-    "Age": 26,
-    "Gender": "male",
-    "House": "Castle Black"
-  }
-*/
-```
-
-!> It's perfectly legal to refer other data maps from a data map. *Be cautious not to create circular dependencies*
-
-```javascript
-const pactum = require('pactum');
-const stash = pactum.stash;
-
-before(() => {
-  stash.addDataMap({
-    'User': {
-      'Default': {
-        'FirstName': '$M{User.FirstNames[0]}',
-        'LastName': '$M{User.LastNames[0]}',
-        'Country': 'North'
-      },
-      'FirstNames': [ 'Jon', 'Ned', 'Ary' ],
-      'LastNames': [ 'Stark', 'Sand', 'Snow' ]
-    }
-  });
-});
-```
-
-### Data Function
-
-Data Functions can ease up your life when working with dynamic values. A Data Function is a custom data handler function that returns some sort of data that can be referenced later.
-
-Use `handler.addDataFunHandler` to add a custom data function handler. To use the data function in the tests or in the template, use `$F{<handler-name>}`.
-
-```javascript
-const pactum = require('pactum');
-const handler = pactum.handler;
-
-handler.addDataFunHandler('GetTimeStamp', () => {
-  return Date.now();
-});
-handler.addDataFunHandler('GetAuthToken', () => {
-  return 'Basic some-token';
-});
-
-await pactum.spec()
-  .post('/api/order')
-  .withHeaders('Authorization', '$F{GetAuthToken}')
-  .withJson({
-    'Item': 'Sword',
-    'CreatedAt': '$F{GetTimeStamp}'
-  });
-```
-
-Data functions also accepts custom data as arguments in the form of array. To pass data use comma separated values after handler name `$F{<handler-name>:<arg1>,<arg2>}`.
-
-```javascript
-handler.addDataFunHandler('GetFormattedDate', (ctx) => {
-  const fmt = ctx.args[0];
-  return moment.format(fmt);
-});
-
-handler.addDataFunHandler('GetSum', (ctx) => {
-  const a = parseInt(ctx.args[0]);
-  const b = parseInt(ctx.args[1]);
-  return a + b;
-});
-
-await pactum.spec()
-  .post('/api/order')
-  .withJson({
-    'Item': 'Sword',
-    'CreatedAt': '$F{GetFormattedDate:dddd}',
-    'Qty': '$F{GetSum:5,10}'
-  });
-```
-
-### Data Store
-
-A data store is a reference of custom response data that is received while running API tests. This comes in handy while running integration or e2e API testing to pass data between tests.
-
-See [Integration Testing](#integration-testing) for more information.
-
-## Loading Data
-
-You can load *Data Templates* & *Data Maps* directly from file system using `loadData` function. You can either group your templates & maps inside *templates* & *maps* folders or place them in the root dir by adding suffix *.template* or *.map* to the json files.
-
-```
-- data/
-  - maps/
-    - User.json
-  - templates/
-    - Address.json
-  - Bank.template.json
-  - Army.map.json
-```
-
-```javascript
-stash.loadData(); // by default it looks for a directory `./data`
-// or
-stash.loadData('/path/to/data/folder');
-```
-
diff --git a/docs/index.html b/docs/index.html
deleted file mode 100644
index ba1216d..0000000
--- a/docs/index.html
+++ /dev/null
@@ -1,52 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <meta charset="UTF-8">
-  <title>pactum - REST API Testing Tool</title>
-  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
-  <meta name="description" content="REST API Testing tool for all level in a test pyramid">
-  <meta name="viewport"
-    content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-  <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/docsify/lib/themes/vue.css">
-</head>
-
-<body>
-  <div id="app"></div>
-  <script>
-    window.$docsify = {
-      name: 'pactum',
-      repo: 'https://github.com/ASaiAnudeep/pactum',
-      auto2top: true,
-      coverpage: true,
-      onlyCover: true,
-      loadNavbar: true,
-      themeColor: '#00008B',
-      copyCode: {
-        buttonText: 'Copy'
-      },
-      search: {
-        paths: [
-          '/',
-          'quick-start',
-          'test-runners',
-          'api-testing',
-          'integration-testing',
-          'mock-server',
-          'component-testing',
-          'data-management',
-          'matchers',
-          'reporting'
-        ]
-      }
-    }
-  </script>
-  <script src="//cdn.jsdelivr.net/npm/docsify/lib/docsify.min.js"></script>
-  <script src="//cdn.jsdelivr.net/npm/docsify/lib/plugins/search.min.js"></script>
-  <script src="//unpkg.com/prismjs/components/prism-bash.min.js"></script>
-  <script src="//unpkg.com/prismjs/components/prism-json.min.js"></script>
-  <script src="//cdn.jsdelivr.net/npm/docsify-copy-code"></script>
-  <script src="//cdn.jsdelivr.net/npm/docsify-tabs@1"></script>
-</body>
-
-</html>
\ No newline at end of file
diff --git a/docs/interactions.md b/docs/interactions.md
deleted file mode 100644
index 50e2266..0000000
--- a/docs/interactions.md
+++ /dev/null
@@ -1,498 +0,0 @@
-# Interactions
-
-Interactions are the way to instruct or train the mock server to respond in a particular way when a particular request is received. An interaction is an individual message that combines a request sent by the consumer & minimal expected response replied by the provider. Interactions help you to control the state of your providers. They are categorized into two:
-
-* Mock Interaction
-* Pact Interaction
-
-The main difference between mock & pact interactions is that mock interaction cannot form a contract while a pact interaction can.
-
-## Adding Interactions
-
-Interactions can be added or removed from the mock server in the following ways.
-
-* When using pactum as a **testing tool**
-  * `pactum.addPactInteraction({ })` - auto removed after the test case execution
-  * `pactum.addInteraction({ })` - auto removed after the test case execution
-* When using pactum as a **testing tool** or **mock server**
-  * `pactum.mock.addDefaultInteraction({ })`
-  * `pactum.mock.addDefaultPactInteraction({ })`
-  * `pactum.mock.addDefaultInteractions([{ }])`
-  * `pactum.mock.addDefaultPactInteractions([{ }])`
-  * `pactum.mock.removeDefaultInteraction('')`
-  * `pactum.mock.clearDefaultInteractions()`
-* Through **remote api**
-  * `/api/pactum/interaction`
-  * `/api/pactum/pactInteraction`
-
-Learn more about these methods at [Mock Server](https://github.com/ASaiAnudeep/pactum/wiki/Mock-Server)
-
-### Mock Interaction
-
-Mock Interaction will have the following properties.
-
-| Property                        | Type        | Description                     |
-| ------------------------------  | ----------  | --------------------------      |
-| id                              | string      | id of the interaction           |
-| provider                        | string      | name of the provider            |
-| flow                            | string      | name of the provider flow       |
-| withRequest                     | **object**  | request details                 |
-| withRequest.method              | **string**  | HTTP method                     |
-| withRequest.path                | **string**  | api path                        |
-| withRequest.headers             | object      | request headers                 |
-| withRequest.query               | object      | query parameters                |
-| withRequest.body                | any         | request body                    |
-| withRequest.ignoreQuery         | boolean     | ignore request query            |
-| withRequest.ignoreBody          | boolean     | ignore request body             |
-| withRequest.graphQL             | object      | graphQL details                 |
-| withRequest.graphQL.query       | **string**  | graphQL query                   |
-| withRequest.graphQL.variables   | object      | graphQL variables               |
-| willRespondWith                 | **any**     | response details                |
-| willRespondWith.status          | **number**  | response status code            |
-| willRespondWith.headers         | object      | response headers                |
-| willRespondWith.body            | any         | response body                   |
-| willRespondWith.fixedDelay      | number      | delays the response by ms       |
-| willRespondWith.randomDelay     | object      | delays the response by ms       |
-| willRespondWith.randomDelay.min | number      | delays the response by ms       |
-| willRespondWith.randomDelay.max | number      | delays the response by ms       |
-| willRespondWith.onCall          | object      | response on consecutive  calls  |
-| willRespondWith(req, res)       | function    | response with custom function   |
-
-The response of a mock interaction can be controlled in three forms:
-1. Static Object
-2. Custom Function
-3. Dynamic Object
-
-#### pactum.addInteraction
-Type: `Function`<br>
-
-```javascript
-// Static Object
-pactum.addInteraction({
-  request: {
-    method: 'GET',
-    path: '/api/currency/INR'
-  },
-  response: {
-    status: 200,
-    headers: {
-      'content-type': 'application/json'
-    },
-    body: {
-      id: 'INR',
-      description: 'Indian Rupee'
-    }
-  }
-});
-
-// Custom Function
-pactum.addInteraction({
-  request: {
-    method: 'GET',
-    path: '/api/currency/INR'
-  },
-  response: function (req, res) {
-    res.status(200);
-    res.send({
-      id: 1,
-      name: 'fake'
-    });
-  }
-});
-
-// Dynamic Object (change behavior on consecutive calls)
-pactum.addDefaultInteraction({
-  request: {
-    method: 'GET',
-    path: '/api/projects/1'
-  },
-  response: {
-    status: 204, // default response
-    onCall: {
-      0: {
-        status: 200,
-        body: 'Success :)'
-      },
-      1: {
-        status: 201
-      },
-      2: {
-        status: 202
-      },
-      5: {
-        status: 500,
-        body: 'No Success :('
-      }
-    }
-  }
-});
-```
-
-### Pact Interaction
-
-| Property                      | Type        | Description                 |
-| -----------------------       | -------     | --------------------------  |
-| id                            | string      | id of the interaction       |
-| provider                      | **string**  | name of the provider        |
-| state                         | **string**  | state of the provider       |
-| uponReceiving                 | **string**  | description of the request  |
-| withRequest                   | **object**  | request details             |
-| withRequest.method            | **string**  | HTTP method                 |
-| withRequest.path              | **string**  | api path                    |
-| withRequest.headers           | object      | request headers             |
-| withRequest.query             | object      | query parameters            |
-| withRequest.body              | any         | request body                |
-| withRequest.graphQL           | object      | graphQL details             |
-| withRequest.graphQL.query     | string      | graphQL query               |
-| withRequest.graphQL.variables | object      | graphQL variables           |
-| willRespondWith               | **object**  | response details            |
-| willRespondWith.status        | **number**  | response status code        |
-| willRespondWith.headers       | object      | response headers            |
-| willRespondWith.body          | any         | response body               |
-
-#### pactum.addPactInteraction
-Type: `Function`<br>
-
-```javascript
-pactum.addPactInteraction({
-  provider: 'currency-service',
-  state: 'there is INR currency',
-  uponReceiving: 'a request for INR currency',
-  request: {
-    method: 'GET',
-    path: '/api/currency/INR'
-  },
-  response: {
-    status: 200,
-    headers: {
-      'content-type': 'application/json'
-    },
-    body: {
-      id: 'INR',
-      description: 'Indian Rupee'
-    }
-  }
-})
-```
-
-## Matching
-
-In real world applications, sometimes it is hard to match an expected request/response with actual request/response.
-
-```javascript
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders',
-    query: {
-      // randomly generated id
-      id: 'p144XiRTu'
-    }
-  },
-  response: {
-    status: 200
-  }
-}
-```
-
-To overcome such issues, **pactum** provides a mechanism for request matching during *[Component Testing](https://github.com/ASaiAnudeep/pactum/wiki/Component-Testing)* & *[Consumer Testing](https://github.com/ASaiAnudeep/pactum/wiki/Consumer-Testing)* and response matching during *[Provider Verification](https://github.com/ASaiAnudeep/pactum/wiki/Provider-Verification)*.
-
-**pactum** matching mechanism is inspired from [Pact - Matching](https://docs.pact.io/getting_started/matching)
-
-It supports following matchers
-
-* `like` or `somethingLike` - matches with the type
-* `regex` or `term` - matches with the regular expression
-* `eachLike` - matches all the elements in the array with the specified type
-* `contains` - checks if actual value contains a specified value in it
-
-Matchers can be applied to
-
-* Path - *supports only regex*
-* Query
-* Headers - *headers are ignored during request matching until explicitly specified*
-* Body
-
-### Type Matching
-
-Often, you will not care what the exact value is at a particular path is, you just care that a value is present and that it is of the expected type.
-
-* `like` or `somethingLike`
-* `eachLike`
-
-#### like
-
-Type matching for primitive data types - *string*/*number*/*boolean*
-
-```javascript
-const { like } = pactum.matchers;
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders',
-    query: {
-      // matches if it has id & of type string
-      id: like('abc')
-    }
-  },
-  response: {
-    status: 200,
-    body: {
-      // matches if it has quantity & active properties with number & bool types
-      quantity: like(2),
-      active: like(true)
-    }
-  }
-}
-```
-
-Type matching for objects in **pactum** deviates from in **pact.io** when matching nested objects.
-
-```javascript
-const { like } = pactum.matchers;
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders'
-  },
-  response: {
-    status: 200,
-    // matches if body is JSON & has quantity & active properties with number & bool types
-    body: like({
-      quantity: 2,
-      active: true
-    })
-  }
-}
-```
-
-```javascript
-// matching doesn't expand to nested objects
-const { like } = pactum.matchers;
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders'
-  },
-  response: {
-    status: 200,
-    // matches if body is JSON object
-    // & it has quantity, active & item properties with number, bool & object types respectively
-    // & item has name & brand properties with 'car' & 'v40' values respectively
-    body: like({
-      quantity: 2,
-      active: true,
-      item: {
-        name: 'car',
-        brand: 'v40'
-      }
-    })
-  }
-}
-```
-
-```javascript
-// to match nested objects with type, we need apply 'like()' explicitly to nested objects
-const { like } = pactum.matchers;
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders'
-  },
-  response: {
-    status: 200,
-    // matches if body is JSON object
-    // & it has quantity, active, item & delivery properties with number, bool & object types respectively
-    // & item has name & brand properties with string types
-    // & delivery has pin property with type number & has state property with 'AP' as value
-    body: like({
-      quantity: 2,
-      active: true,
-      item: like({
-        name: 'car',
-        brand: 'v40'
-      }),
-      delivery: {
-        pin: like(500081),
-        state: 'AP'
-      }
-    })
-  }
-}
-```
-
-#### eachLike
-
-*eachLike* is similar to *like* but applies to arrays.
-
-```javascript
-const { eachLike } = pactum.matchers;
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders'
-  },
-  response: {
-    status: 200,
-    // matches if body is an array of JSON objects
-    // & each object in array should have it has quantity, active, item
-    // & item has name property with string type
-    // & item has colors property with array of strings
-    body: eachLike({
-      quantity: 2,
-      active: true,
-      item: like({
-        name: 'car',
-        colors: eachLike('blue')
-      }
-    })
-  }
-}
-```
-
-### Regex Matching
-
-Sometimes you will have keys in a request or response with values that are hard to know beforehand - timestamps and generated IDs are two examples.
-
-What you need is a way to say "I expect something matching this regular expression, but I don't care what the actual value is".
-
-#### regex
-
-```javascript
-const { regex } = pactum.matchers;
-const interaction = {
-  request: {
-    method: 'GET',
-    path: regex('/api/projects/\\d+')
-  },
-  response: {
-    status: 200,
-    body: {
-      name: 'xyx'
-      birthDate: regex({
-        generate: '03/05/2020',
-        matcher: /\d{2}\/\d{2}\/\d{4}/
-      })
-    }
-  }
-}
-```
-
-## Request Matching
-
-When a request is received by the pactum's mock server, it will attempt to match each interaction with the request. If a match is found, it will respond with the response details in the matched interaction. If no match is found, the mock server will respond with status *404*.
-
-*As a rule of thumb, you generally want to use exact matching when you're setting up the expectations for a request because you're under control of the data at this stage, and according to Postel's Law, we want to be "strict" with what we send out. Note that the request matching does not allow "unexpected" values to be present in JSON request bodies or query strings. (It does however allow extra headers, because we found that writing expectations that included the headers added by the various frameworks that might be used resulted in tests that were very fiddly to maintain.)*
-
-> Applicable during *component testing* and *consumer testing*
-
-```javascript
-const pactum = require('pactum');
-const { like, somethingLike, term, regex, eachLike, contains } = pactum.matchers;
-
-it('Matchers - Path & Query', () => {
-  return pactum
-    .addInteraction({
-      request: {
-        method: 'GET',
-        // Matches path with value in matcher. Value inside generate is used in contract testing.
-        path: regex({ generate: '/api/projects/1', matcher: /\/api\/projects\/\d+/ }),
-        query: {
-          // Matches with type. Date can be any string.
-          date: like('08/04/2020'),
-          // No matcher is applied to the age.
-          age: '10'
-        } 
-      },
-      response: {
-        status: 200
-      }
-    })
-    .get('http://localhost:9393/api/projects/1')
-    .withQuery('date', '12/00/9632')
-    .expectStatus(200);
-});
-
-it('Matchers - Body', () => {
-  return pactum
-    .addInteraction({
-      request: {
-        method: 'POST',
-        path: '/api/person',
-        // checks if the body has array of objects with id, name & address
-        body: eachLike({
-          // checks if id matches with regular expression
-          id: term({ generate: 123, matcher: /\d+/ }),
-          name: 'Bark',
-          address: like({
-            // checks if city is string
-            city: 'some',
-            // checks if pin is number
-            pin: 123 
-          })
-        })
-      },
-      response: {
-        status: 200
-      }
-    })
-    .post('http://localhost:9393/api/person')
-    .withBody([{
-      id: 100,
-      name: 'Dark',
-      address: {
-        city: 'another',
-        pin: 5000
-      }
-    }])
-    .expectStatus(200);
-});
-```
-
-## Response Matching
-
-*You want to be as loose as possible with the matching for the response though. This stops the tests being brittle on the provider side. Generally speaking, it doesn't matter what value the provider actually returns during verification, as long as the types match. When you need certain formats in the values (eg. URLS), you can use regex. Really really consider before you start introducing too many matchers however - for example, yes, the provider might be currently returning a GUID, but would anything in your consumer really break if they returned a different format of string ID? (If it did, that's a nasty code smell!) Note that during provider verification, following Postel's Law of being "relaxed" with what we accept, "unexpected" values in JSON response bodies are ignored. This is expected and is perfectly OK. Another consumer may have an expectation about that field.*
-
-> Applicable during *provider verification*
-
-```javascript
-const pactum = require('pactum');
-const { like, somethingLike, term, regex, eachLike, contains } = pactum.matchers;
-
-it('Matchers - Body', () => {
-  return pactum
-    .addInteraction({
-      request: {
-        method: 'POST',
-        path: '/api/person'
-      },
-      response: {
-        status: 200,
-        // create a single array of object with id, name & address
-        body: eachLike({
-          // creates a id with 123
-          id: term({ generate: 123, matcher: /\d+/ }),
-          name: 'Bark',
-          address: like({
-            // creates a city with 'hyd'
-            city: 'hyd',
-            // creates a pin with '500081'
-            pin: 500081 
-          })
-        })
-      }
-    })
-    .get('http://localhost:9393/api/person')
-    .expectStatus(200)
-    .expectJson([{
-      id: 123,
-      name: 'Bark',
-      address: {
-        cit: 'hyd',
-        pin: 500081
-      }
-    }]);
-});
-```
-
-----------------------------------------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/docs/matching.md b/docs/matching.md
deleted file mode 100644
index 7d49cf4..0000000
--- a/docs/matching.md
+++ /dev/null
@@ -1,277 +0,0 @@
-# Matching
-
-In real world applications, sometimes it is hard to match an expected request/response with actual request/response. To overcome such issues, **pactum** provides a mechanism for request & response matching.
-
-## Table of Contents
-
-* [Supported Matchers](#supported-matchers)
-* [Type Matching](#type-matching)
-  * [like](#like)
-  * [eachLike](#eachLike)
-* [Regex Matching](#regex-matching)
-  * [regex](#regex)
-
-## Supported Matchers
-
-It supports following matchers
-
-* `like` - matches with the type
-* `eachLike` - matches all the elements in the array with the specified type
-* `regex` - matches with the regular expression
-* `includes` - checks if actual value includes a specified value in it
-* `oneOf` - checks if actual value is one of the expected value
-* `expression` - checks if actual value is satisfies the expected expression
-
-Matchers are applied on JSON
-  
-* during response validation - [expectJsonMatch](api-testing#expectJsonMatch)
-* during request matching for interactions in [Mock Server](mock-server)
-* during request and response matching for [Contract Testing](contract-testing)
-
-## Type Matching
-
-Often, you will not care what the exact value is at a particular path is, you just care that a value is present and that it is of the expected type.
-
-* `like`
-* `eachLike`
-
-### like
-
-Type matching for primitive data types - *string*/*number*/*boolean*
-
-#### Type Matching single property in a JSON
-
-```javascript
-const { like } = require('pactum').matchers;
-
-// matches if it is a JSON object
-// & it has 'id' & 'name' properties 
-// & where 'id' is of 'number' type & 'name' equal to 'jon'
-const actual = {
-  id: like(1),
-  name: 'jon'
-}
-
-// actual === exp1 -> True
-const exp1 = {
-  id: 100987,
-  name: 'jon'
-}
-
-// actual === exp2 -> True
-const exp2 = {
-  id: 100987,
-  name: 'jon',
-  active: true
-}
-
-// actual === exp3 -> False
-const exp3 = {
-  id: "C17",
-  name: 'jon'
-}
-```
-
-#### Type Matching whole JSON
-
-```javascript
-const { like } = require('pactum').matchers;
-
-// matches if it is a JSON object
-// & it has 'id' & 'name' properties 
-// & where 'id' is of 'number' type & 'name' is of 'string' type
-const actual = like({
-  id: 1,
-  name: 'jon'
-})
-
-// actual === exp1 -> True
-const exp1 = {
-  id: 100987,
-  name: 'snow'
-}
-
-// actual === exp2 -> False
-const exp2 = {
-  id: 'C17',
-  name: 'jon'
-}
-```
-
-#### Type Matching Nested Objects in JSON
-
-```javascript
-const { like } = require('pactum').matchers;
-
-// matches if it is a JSON object
-// & it has quantity, active & item properties 
-// & with number, bool & object types respectively
-// & item has name & brand properties with 'car' & 'v40' values respectively
-const actual = like({
-  quantity: 2,
-  active: true,
-  item: {
-    name: 'car',
-    brand: 'v40'
-  }
-});
-
-// actual === exp1 -> True
-const exp1 = {
-  quantity: 1,
-  active: false,
-  item: {
-    name: 'car',
-    brand: 'v40'
-  }
-}
-
-// actual === exp2 -> False
-const exp2 = {
-  quantity: 1,
-  active: false,
-  item: {
-    name: 'bus',
-    brand: 'v40'
-  }
-}
-```
-
-To match nested objects with type, we need apply `like()` explicitly to nested objects
-
-```javascript
-const { like } = require('pactum').matchers;
-
-// matches if it is a JSON object
-// & it has quantity, active & item properties 
-// & with number, bool & object types respectively
-// & item has name & brand properties with string types
-const actual = like({
-  quantity: 2,
-  active: true,
-  item: like({
-    name: 'car',
-    brand: 'v40'
-  })
-});
-
-// actual === exp1 -> True
-const exp1 = {
-  quantity: 1,
-  active: false,
-  item: {
-    name: 'car',
-    brand: 'v40'
-  }
-}
-
-// actual === exp2 -> True
-const exp2 = {
-  quantity: 1,
-  active: false,
-  item: {
-    name: 'bus',
-    brand: 'v40'
-  }
-}
-
-// actual === exp3 -> False
-const exp3 = {
-  quantity: 1,
-  active: false,
-  item: {
-    name: 'bus'
-  }
-}
-```
-
-### eachLike
-
-*eachLike* is similar to *like* but applies to arrays.
-
-```javascript
-const { eachLike } = require('pactum-matchers');
-
-// matches if it is an array 
-// & each item in the array is an object
-// & each object should have quantity, active, product properties
-// & quantity, active, product should be of types number, boolean & object
-// & product has a name property with string type
-// & product has a colors property with array of strings
-const actual = eachLike({
-  quantity: 2,
-  active: true,
-  product: like({
-    name: 'car',
-    colors: eachLike('blue')
-  })
-});
-
-// actual === exp1 -> True
-const exp1 = [
-  {
-    quantity: 1,
-    active: false,
-    product: {
-      name: 'car',
-      colors: [ 'red' ]
-    }
-  },
-  {
-    quantity: 10,
-    active: true,
-    product: {
-      name: 'bus',
-      colors: [ 'red', 'black' ]
-    }
-  }
-];
-
-// actual === exp2 -> False
-const exp2 = [
-  {
-    quantity: 1,
-    active: false,
-    product: {
-      name: 'car',
-      colors: []
-    }
-  },
-  {
-    quantity: 10,
-    active: true,
-    product: {
-      name: 'bus',
-      colors: [ 1, 2 ]
-    }
-  }
-];
-```
-
-## Regex Matching
-
-Sometimes you will have keys in a request or response with values that are hard to know beforehand - timestamps and generated IDs are two examples.
-
-What you need is a way to say "I expect something matching this regular expression, but I don't care what the actual value is".
-
-### regex
-
-```javascript
-const { regex } = require('pactum-matchers');
-const actual = {
-  name: 'Jon'
-  birthDate: regex(/\d{2}\/\d{2}\/\d{4}/)
-}
-
-// actual === exp1 -> True
-const exp1 = {
-  name: 'Jon',
-  birthDate: '02/02/2020'
-}
-
-// actual === exp2 -> False
-const exp1 = {
-  name: 'Jon',
-  birthDate: '2/2/2020'
-}
-```
diff --git a/docs/mock-server.md b/docs/mock-server.md
deleted file mode 100644
index 71739d1..0000000
--- a/docs/mock-server.md
+++ /dev/null
@@ -1,770 +0,0 @@
-# Mock Server
-
-Mock Server allows you to mock any server or service via HTTP or HTTPS, such as a REST endpoint. Simply it is a simulator for HTTP-based APIs.
-
-At one end **pactum** is a REST API testing tool and on the other, it can act as a standalone mock server. It packs with a powerful request & response matching & you can spin it up in a matter of seconds.
-
-Mock server comes in handy while using this library for component & contract testing.
-
-## Getting Started
-
-### Basic Setup
-
-The below code will run the pactum mock server on port 3000
-
-<!-- tabs:start -->
-
-#### ** server.js **
-
-```javascript
-const mock = require('pactum').mock;
-mock.start(3000);
-```
-
-<!-- tabs:end -->
-
-Running the mock server.
-
-```shell
-node server.js
-```
-
-Check health
-
-```shell
-# Returns OK
-curl http://localhost:3000/api/pactum/health
-```
-
-### Start Mock Server
-
-Use `start` to start the mock server on default port 9393 or send a port number as a parameter. It returns a promise. *Waiting for the server to start will be useful while running the mock server along with your unit or component tests.*
-
-```javascript
-// starts mock server on port 9393
-await mock.start();
-```
-
-```javascript
-// starts mock server on port 3000
-await mock.start(3000);
-```
-
-### Stop Mock Server
-
-Use `stop` to stop the mock server. It returns a promise. *Waiting for the server to stop will be useful while running the mock server along with your unit or component tests.*
-
-```javascript
-await mock.stop();
-```
-
-## Adding Behavior
-
-By now, you know how to start & stop a mock server. To add behavior, we need to add to it. An interaction contains request & response details. When a real request is sent to mock server, it will try to match the received request with interactions request. If a match is found it will return the specified response or 404 will be returned.
-
-### Interactions
-
-The simplest way to add behavior to the mock server is through interactions. Use `addInteraction` to add a interaction to the server. It has `request` & `response` objects to handle a request. When the mock server receives a request, it will match the request with interactions `request` properties. If the request matches, the mock server will respond with details in `response` object.
-
-Matching:
-
-* Performs *exact match* on received HTTP Method & Path.
-* Performs *strong match* on the received request's query params & JSON body.
-* Performs *loose match* on received headers.
-* Performs *loose match* on the received request's query params & JSON body when **strict** is `false`.
-
-`addInteraction` returns a string containing the id of the interaction. (*This id will be useful when you want to add assertions based on the call count or to check whether the interaction is exercised or not.*)
-
-```javascript
-const mock = require('pactum').mock;
-
-mock.addInteraction({
-  strict: false,
-  request: {
-    method: 'GET',
-    path: '/api/users/1'
-  },
-  response: {
-    status: 200,
-    body: {
-      id: 1,
-      name: 'Jon'
-    }
-  }
-});
-
-mock.start(3000);
-```
-
-* Invoking GET `/api/users/1` will return a JSON with 200 status code.
-* Invoking GET `/api/users` will return a status code 404.
-* Invoking GET `/api/users/2` will return a status code 404.
-* Invoking POST `/api/users` will return a status code 404.
-
-Note on how the mock server performs an exact match on HTTP method & path. If a match is not found it will return a status code 404.
-
-To further distinguish the responses, let's add two interactions with query params
-
-```javascript
-mock.addInteraction({
-  strict: false,
-  request: {
-    method: 'GET',
-    path: '/api/users',
-    queryParams: {
-      id: 1
-    }
-  },
-  response: {
-    status: 200,
-    body: {
-      id: 1,
-      name: 'Jon'
-    }
-  }
-});
-
-mock.addInteraction({
-  strict: false,
-  request: {
-    method: 'GET',
-    path: '/api/users',
-    queryParams: {
-      id: 2
-    }
-  },
-  response: {
-    status: 200,
-    body: {
-      id: 2,
-      name: 'Snow'
-    }
-  }
-});
-```
-
-* Invoking GET `/api/users?id=1` will return project-1 details.
-* Invoking GET `/api/users?id=1&name=snow` will still return project-1 details.
-* Invoking GET `/api/users?id=1&foo=boo` will still return project-1 details.
-* Invoking GET `/api/users?id=2` will return project-2 details.
-* Invoking GET `/api/users` will return a status code 404.
-* Invoking GET `/api/users?id=3` will return a status code 404.
-* Invoking GET `/api/users?name=Jon` will return a status code 404.
-
-When query params are mentioned in the interaction, the received request is matched when it has the specified query params. Same applies for headers & body.
-
-Let's look at an example
-
-```javascript
-mock.addInteraction({
-  strict: false,
-  request: {
-    method: 'POST',
-    path: '/api/users',
-    body: {
-      id: 3,
-      married: false,
-      country: 'True North'
-    }
-  },
-  response: {
-    status: 200
-  }
-})
-```
-
-Posting the below JSON to `/api/users` will return a 200 response.
-
-```json
-{
-  "id": 3,
-  "name": "Jon",
-  "married": false,
-  "house": "Stark",
-  "country": "True North"
-}
-```
-
-Posting the below JSON to `/api/users` will return a 404 response. The *id* & *country* fields won't match with the above interaction.
-
-```json
-{
-  "id": 4,
-  "name": "Jon",
-  "married": false,
-  "house": "Stark"
-}
-```
-
-#### interaction Options
-
-| Property                  | Description                     |
-| ------------------------  | ------------------------------  |
-| id                        | id of the interaction           |
-| strict                    | enable/disable strict matching  |
-| provider                  | name of the provider            |
-| flow                      | name of the flow                |
-| request                   | request details                 |
-| request.method            | HTTP method                     |
-| request.path              | api path                        |
-| request.pathParams        | api path params                 |
-| request.headers           | request headers                 |
-| request.queryParams       | query parameters                |
-| request.body              | request body                    |
-| request.graphQL           | graphQL details                 |
-| request.graphQL.query     | graphQL query                   |
-| request.graphQL.variables | graphQL variables               |
-| response                  | response details                |
-| response.status           | response status code            |
-| response.headers          | response headers                |
-| response.body             | response body                   |
-| response.fixedDelay       | delays the response by ms       |
-| response.randomDelay      | random delay details            |
-| response.randomDelay.min  | delay the response by min ms    |
-| response.randomDelay.max  | delay the response by max ms    |
-| response.onCall           | response on consecutive calls   |
-| response(req, res)        | response with custom function   |
-
-#### Path Params
-
-Example of using path params.
-
-```js
-mock.addInteraction({
-  request: {
-    method: 'GET',
-    path: '/api/users/{userId}',
-    pathParams: {
-      userId: '1'
-    }
-  },
-  response: {
-    status: 200,
-    body: {
-      id: 1,
-      name: 'Jon'
-    }
-  }
-});
-```
-
-#### Behavior on consecutive calls
-
-`onCall` defines the behavior of the interaction on the *nth* call. Useful for testing sequential interactions.
-
-```javascript
-mock.addInteraction({
-  request: {
-    method: 'GET',
-    path: '/api/health'
-  },
-  response: {
-    onCall: {
-      0: {
-        status: 500
-      },
-      1: {
-        status: 200,
-        body: 'OK'
-      }
-    }
-  }
-})
-```
-
-* Invoking GET `/api/health` will return a status code 500.
-* Invoking GET `/api/health` again will return a status code 200.
-* Invoking GET `/api/health` again will return a status code 404.
-
-Note how the behavior of interaction falls back to the default behavior (*404*) on the third call.
-
-We can also define the default behavior by providing normal response details along with `onCall` details.
-
-```javascript
-response : {
-  status: 200,
-  onCall: {
-    0: {
-      status: 500
-    }
-  }
-}
-```
-
-#### Delays
-
-`fixedDelay` & `randomDelay` adds delay to the response. The following interaction will send a response after *1000 ms*.
-
-```javascript
-mock.addInteraction({
-  request: {
-    method: 'POST',
-    path: '/api/users',
-    body: {
-      id: 3
-    }
-  },
-  response: {
-    status: 200,
-    fixedDelay: 1000
-  }
-})
-```
-
-### Handlers
-
-Interaction handlers help us to reuse same kind of interactions with modifications. Use `handler.addInteractionHandler` function to temporarily store interactions & later use the handler name to add them to the mock server.
-
-It accepts two arguments
-
-* handler name - a string to refer the interaction later
-* callback function - it should return a interaction or reference to other interaction
-
-```javascript
-const mock = pactum.mock;
-const handler = pactum.handler;
-
-handler.addInteractionHandler('get product', (ctx) => {
-  return {
-    request: {
-      method: 'GET',
-      path: '/api/inventory',
-      queryParams: {
-        product: ctx.data.product
-      }
-    },
-    response: {
-      status: 200,
-      body: {
-        "InStock": ctx.data.inStock
-      }
-    }
-  }    
-});
-
-mock.addInteraction('get product', { product: 'iPhone', inStock: true });
-mock.addInteraction('get product', { product: 'iPhone', inStock: false });
-
-mock.start(3000);
-```
-
-Interaction handlers can refer other interaction handlers to make them more reusable. Instead of returning interaction, return an object with `name` & optional `data` property.
-
-```javascript
-const mock = pactum.mock;
-const handler = pactum.handler;
-
-handler.addInteractionHandler('get product', (ctx) => {
-  return {
-    request: {
-      method: 'GET',
-      path: '/api/inventory',
-      queryParams: {
-        product: ctx.data.product
-      }
-    },
-    response: {
-      status: 200,
-      body: {
-        "InStock": ctx.data.inStock
-      }
-    }
-  }    
-});
-
-handler.addInteractionHandler('get product in stock', () => {
-  return { name: 'get product', data: { product: 'iPhone', inStock: true } };   
-});
-
-handler.addInteractionHandler('get product out of stock', () => {
-  return { name: 'get product', data: { product: 'iPhone', inStock: false } };   
-});
-
-mock.addInteraction('get product in stock');
-mock.addInteraction('get product out of stock');
-
-mock.start(3000);
-```
-
-## Data Management
-
-Data Management can also be applied to the mock server to re-use mock data across interactions. Learn more about data management with **pactum** at [Data Management](#data-management)
-
-```javascript
-const pactum = require('pactum');
-const stash = pactum.stash;
-const mock = pactum.mock;
-
-stash.addDataTemplate({
-  'User:New': {
-    "FirstName": "Jon",
-    "LastName": "Snow",
-    "Age": 26,
-    "Gender": "male",
-    "House": "Castle Black"
-  }
-});
-
-mock.addInteraction({
-  request: {
-    method: 'GET',
-    path: '/api/users'
-  },
-  response: {
-    status: 200,
-    headers: {
-      'content-type': 'application/json'
-    },
-    body: [
-      {
-        '@DATA:TEMPLATE@': 'User:New'
-      },
-      {
-        '@DATA:TEMPLATE@': 'User:New',
-        'OVERRIDES': {
-          'House': 'WinterFell'
-        }
-      }
-    ]
-  }
-});
-
-mock.start(3000);
-```
-
-## Matching
-
-Allows matching of request/response with a set of matchers. See [Matching](#matching) for more usage details.
-
-Matchers can be applied to
-
-* Path
-* Query Params
-* Headers
-* Body (*JSON*)
-
-### Type Matching
-
-Often, you will not care what the exact value is at a particular path is, you just care that a value is present and that it is of the expected type.
-
-* `like` or `somethingLike`
-* `eachLike`
-
-#### like
-
-Type matching for primitive data types - *string*/*number*/*boolean*
-
-```javascript
-const { like } = require('pactum-matchers');
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders',
-    queryParams: {
-      // matches if it has id & of type string
-      id: like('abc')
-    }
-  },
-  response: {
-    status: 200,
-    body: {
-      // Note: Response Matching is used in Contract Testing
-      // matches if it has quantity & active properties with number & bool types
-      quantity: like(2),
-      active: like(true)
-    }
-  }
-}
-```
-
-Type matching for objects in **pactum** deviates from in **pact.io** when matching nested objects.
-
-```javascript
-const { like } = require('pactum-matchers');
-const interaction = {
-  request: {
-    method: 'POST',
-    path: '/api/orders',
-    // matches if the body is JSON 
-    // & it has quantity & active properties 
-    // & with number & boolean types respectively
-    body: like({
-      quantity: 2,
-      active: true
-    })
-  },
-  response: {
-    status: 200
-  }
-}
-```
-
-```javascript
-// matching doesn't expand to nested objects
-const { like } = require('pactum-matchers');
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders'
-  },
-  response: {
-    status: 200,
-    // Note: Response Matching is used in Contract Testing
-    // matches if body is JSON object
-    // & it has quantity, active & item properties 
-    // & with number, bool & object types respectively
-    // & item has name & brand properties with 'car' & 'v40' values respectively
-    body: like({
-      quantity: 2,
-      active: true,
-      item: {
-        name: 'car',
-        brand: 'v40'
-      }
-    })
-  }
-}
-```
-
-```javascript
-// to match nested objects with type, we need apply 'like()' explicitly to nested objects
-const { like } = require('pactum-matchers');
-const interaction = {
-  request: {
-    method: 'POST',
-    path: '/api/orders',
-    // matches if body is JSON object
-    // & it has quantity, active, item & delivery properties 
-    // & with number, bool & object types respectively
-    // & item has name & brand properties with string types
-    // & delivery has pin property with type number 
-    // & delivery has state property with 'AP' as value
-    body: like({
-      quantity: 2,
-      active: true,
-      item: like({
-        name: 'car',
-        brand: 'v40'
-      }),
-      delivery: {
-        pin: like(500081),
-        state: 'AP'
-      }
-    })
-  },
-  response: {
-    status: 200
-  }
-}
-```
-
-#### eachLike
-
-*eachLike* is similar to *like* but applies to arrays.
-
-```javascript
-const { eachLike } = require('pactum-matchers');
-const interaction = {
-  request: {
-    method: 'GET',
-    path: '/api/orders'
-  },
-  response: {
-    status: 200,
-    // Note: Response Matching is used in Contract Testing
-    // matches if body is an array 
-    // & each item in the array is an object
-    // & each object should have quantity, active, product properties
-    // & quantity, active, product should be of types number, boolean & object
-    // & product has a name property with string type
-    // & product has a colors property with array of strings
-    body: eachLike({
-      quantity: 2,
-      active: true,
-      product: like({
-        name: 'car',
-        colors: eachLike('blue')
-      }
-    })
-  }
-}
-```
-
-### Regex Matching
-
-Sometimes you will have keys in a request or response with values that are hard to know beforehand - timestamps and generated IDs are two examples.
-
-What you need is a way to say "I expect something matching this regular expression, but I don't care what the actual value is".
-
-#### regex
-
-`regex` accepts a value and a matcher as arguments.
-
-```javascript
-const { regex } = require('pactum-matchers');
-const interaction = {
-  request: {
-    method: 'POST',
-    path: '/api/projects/12',
-    body: {
-      name: 'Jon'
-      birthDate: regex('03/05/2020', /\d{2}\/\d{2}\/\d{4}/)
-    }
-  },
-  response: {
-    status: 200
-  }
-}
-```
-
-## Remote API
-
-Pactum allows us to add or remove interactions dynamically through the REST API.
-Once the server is started, interact with the following API to control the mock server.
-
-```javascript
-const mock = require('pactum').mock;
-mock.start(3000);
-```
-
-### Interactions
-
-#### /api/pactum/interactions
-
-##### GET
-
-Returns a single or all interactions.
-
-```Shell
-# Fetches a interaction with id "m1uh9"
-curl --location --request GET 'http://localhost:9393/api/pactum/interactions?id=m1uh9'
-
-# Fetches all interactions
-curl --location --request GET 'http://localhost:9393/api/pactum/interactions'
-```
-
-Response - returns all the interactions
-
-```JSON
-[
-  {
-    "id": "<id>",
-    "exercised": false,
-    "callCount": 0,
-    "request": {
-      "method": "GET",
-      "path": "/api/projects/2",
-      "query": {
-        "name": "fake"
-      }
-    },
-    "response": {
-      "status": 200,
-      "headers": {
-        "content-type": "application/json"
-      },
-      "body": {
-        "id": 1,
-        "name": "fake"
-      }
-    }
-  }
-]
-```
-
-##### POST
-
-Adds multiple interactions to the server.
-
-```Shell
-curl --location --request POST 'http://localhost:9393/api/pactum/interactions' \
---header 'Content-Type: application/json' \
---data-raw '[{
-    "request": {
-        "method": "GET",
-        "path": "/api/projects/2",
-        "query": {
-            "name": "fake"
-        }
-    },
-    "response": {
-        "status": 200,
-        "headers": {
-            "content-type": "application/json"
-        },
-        "body": {
-            "id": 1,
-            "name": "fake"
-        }
-    }
-  }]'
-```
-
-Response - returns the interaction id.
-
-```JSON
-[ "x121w" ] 
-```
-
-##### DELETE
-
-Removes a interaction or all interactions from the mock server.
-
-```Shell
-# Removes a single interaction with id m1uh9
-curl --location --request DELETE 'http://localhost:9393/api/pactum/interactions?id=m1uh9'
-
-# Removes all interactions
-curl --location --request DELETE 'http://localhost:9393/api/pactum/interactions'
-```
-
-### Interaction Handlers
-
-Interaction Handler allows us to dynamically enable & reuse interactions in the mock server. Let's say you have a mock server running on port 3000 with one interaction handler.
-
-```javascript
-const pactum = require('pactum');
-const mock = pactum.mock;
-const handler = pactum.handler;
-
-handler.addInteractionHandler('get user with', (ctx) => {
-  const user = db.getUser(ctx.data.id);
-  return {
-    request: {
-      method: 'GET',
-      path: `/api/users/${ctx.data.id}`
-    },
-    response: {
-      status: 200,
-      body: user
-    }
-  }
-});
-
-mock.start(3000);
-```
-
-If you start the above mock server, by default it will have zero interactions in it. To add the interaction with handler name `'get user with'`, perform the following request.
-
-```Shell
-curl --location --request POST 'http://localhost:9393/api/pactum/handlers' \
---header 'Content-Type: application/json' \
---data-raw '[ { "name": "get user with", "data": { "id": "some-random-id" } } ]'
-```
-
-Response - returns the interaction id.
-
-```JSON
-[ "x121w" ]
-```
-
-## Next
-
-----
-
-<a href="#/api-testing" >
-  <img src="https://img.shields.io/badge/PREV-API%20Testing-orange" alt="API Testing" align="left" style="display: inline;" />
-</a>
-<a href="#/component-testing" >
-  <img src="https://img.shields.io/badge/NEXT-Component%20Testing-blue" alt="Component Testing" align="right" style="display: inline;" />
-</a>
\ No newline at end of file
diff --git a/docs/pactum.md b/docs/pactum.md
deleted file mode 100644
index 3785317..0000000
--- a/docs/pactum.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# pactum
-
-![Build](https://github.com/ASaiAnudeep/pactum/workflows/Build/badge.svg?branch=master)
-![Coverage](https://img.shields.io/codeclimate/coverage/ASaiAnudeep/pactum)
-![Downloads](https://img.shields.io/npm/dt/pactum)
-![Size](https://img.shields.io/bundlephobia/minzip/pactum)
-![Platform](https://img.shields.io/node/v/pactum)
-
-**pactum** is a REST API Testing Tool used to write e2e, integration, contract & component (*or service level*) tests. It comes with a powerful **mock server** which can control the state of external dependencies & combines the implementation of a consumer-driven contract library [Pact](https://docs.pact.io) for JavaScript.
-
-## Features
-
-* Lightweight
-* Clear & Comprehensive Testing Style
-* Works with **cucumber**, **mocha**, **jest**
-* Elegant Data Management
-* Customizable Assertions & Retry Mechanisms
-* Bundles with a **Powerful Mock Server**
-* Ideal for *component*, *contract*, *integration* & *e2e* testing of APIs
-* Reporting
-
-## Experimental
-
-- E2E Testing
-- Fuzz Testing
-- Snapshot Testing
-
-## Road Map
-
-* More Matchers
-* Visual API Testing
-
-## Tutorials
-
-* [Quick Start](quick-start)
-* [API Testing](api-testing)
-* [Integration Testing](integration-testing)
-* [E2E Testing](e2e-testing)
-* [Fuzz Testing](fuzz-testing)
-* [Mock Server](mock-server)
-* [Component Testing](component-testing)
-* [Contract Testing](contract-testing)
-  * [Consumer Testing](consumer-testing)
-  * [Provider Verification](provider-verification)
-* [Data Management](data-management)
-* [Matching](matching)
-* [Reporting](reporting)
-
-## Notes
-
-Inspired from [frisby](https://docs.frisbyjs.com/) testing style & [pact](https://docs.pact.io) interactions.
-
-----
-
-<a href="#/quick-start" >
-  <img src="https://img.shields.io/badge/NEXT-Quick%20Start-blue" alt="Quick Start" align="right" style="display: inline;" />
-</a>
diff --git a/docs/provider-verification.md b/docs/provider-verification.md
deleted file mode 100644
index da9dd62..0000000
--- a/docs/provider-verification.md
+++ /dev/null
@@ -1,80 +0,0 @@
-# Provider Verification
-
-Provider verification is the second step in contract testing. Each request in the pact file is replayed against the provider, and the response is compared with the expected response in the pact file. If the two match, then we know the consumer and provider are compatible.
-
-## Table of contents
-
-* [Getting Started](#getting-started)
-* [API](#api)
-
-## Getting Started
-
-Pacts from **pact-broker**
-
-```javascript
-await pactum.provider.validate({
-  pactBrokerUrl: 'http://pact-broker:9393',
-  providerBaseUrl: 'http://user-service:3000',
-  provider: 'user-service',
-  providerVersion: '1.2.3'
-});
-```
-
-Pacts from **local**
-
-```javascript
-await pactum.provider.validate({
-  pactFilesOrDirs: [ './path/to/pacts' ],
-  providerBaseUrl: 'http://user-service:9393',
-  provider: 'user-service'
-});
-```
-
-Verification with **state handlers** & **custom provider headers**
-
-```javascript
-await pactum.provider.validate({
-  pactFilesOrDirs: [ './path/to/pacts' ],
-  providerBaseUrl: 'http://user-service:9393',
-  provider: 'user-service',
-  stateHandlers: {
-    'there is an order with id 1': async function() {
-      // update database with an order with id 1
-    },
-    'there are no orders': async function() {
-      // clean all orders in database
-    }
-  },
-  customProviderHeaders: {
-    'authorization': 'Basic =QBaX45BhJ4'
-  }
-});
-```
-
-## API
-
-### pactum.provider
-
-#### validate
-Type: `Function`<br>
-Returns: `Promise`<br>
-
-| Options                     | Description                                                                           |
-| --------------------------- | ------------------------------------------------------------------------------------- |
-| `providerBaseUrl`           | running API provider host endpoint                                                    |
-| `provider`                  | name of the provider                                                                  |
-| `providerVersion`           | provider version, required to publish verification results to a broker                |
-| `stateHandlers`             | provider state handlers used to configure the state in the Provider                   |
-| `customProviderHeaders`     | Header(s) to add to any requests to the provider service                              |
-| `pactFilesOrDirs`           | array of local pact files or directories                                              |
-| `pactBrokerUrl`             | URL of the Pact Broker to retrieve pacts from. Required if not using pactFilesOrDirs  |
-| `pactBrokerUsername`        | username for Pact Broker basic authentication                                         |
-| `pactBrokerPassword`        | password for Pact Broker basic authentication                                         |
-| `pactBrokerToken`           | bearer token for Pact Broker authentication                                           |
-| `publishVerificationResult` | publish verification result to Broker                                                 |
-
-----
-
-<a href="#/consumer-testing" >
-  <img src="https://img.shields.io/badge/PREV-Consumer%20Testing-orange" alt="Consumer Testing" align="left" style="display: inline;" />
-</a>
\ No newline at end of file
diff --git a/docs/quick-start.md b/docs/quick-start.md
deleted file mode 100644
index 1a77da3..0000000
--- a/docs/quick-start.md
+++ /dev/null
@@ -1,99 +0,0 @@
-# Quick Start
-
-To get started we need to have NodeJS (>=8) installed in our system.
-
-## Installation
-
-**pactum** is available as a npm package to download. Add it as a dependency to a new project or existing project.
-
-### New Project
-
-```shell
-# create new folder
-mkdir pactum-api-testing
-cd pactum-api-testing
-
-# initialize npm
-npm init -y
-
-# install pactum as a dev dependency
-npm install --save-dev pactum
-```
-
-### Existing Project
-
-```shell
-# move to project folder
-cd <existing-project-folder>
-
-# install pactum as a dev dependency
-npm install --save-dev pactum
-```
-
-## Running Testing
-
-!> **pactum** is not a test runner. It needs to be used alongside with a test runner like **mocha**, **jest**, **jasmine** or **cucumber**.
-
-Install a test runner that supports *promises*.
-
-```shell
-# install a test runner
-npm install mocha -g
-```
-
-Create a JS file & copy the below code
-
-<!-- tabs:start -->
-
-#### ** test.js **
-
-```javascript
-const pactum = require('pactum');
-
-it('should be a teapot', async () => {
-  await pactum.spec()
-    .get('http://httpbin.org/status/418')
-    .expectStatus(418);
-});
-```
-
-<!-- tabs:end -->
-
-Running the test
-
-```shell
-# mocha is a test framework to execute test cases
-mocha test.js
-```
-
-## Mock Server
-
-**pactum** can also be used as a standalone mock server or a service virtualization tool to generate pact files for contract testing.
-
-<!-- tabs:start -->
-
-#### ** server.js **
-
-```js
-const mock = require('pactum').mock;
-mock.start(3000);
-```
-
-<!-- tabs:end -->
-
-Running the mock server
-
-```shell
-node server.js
-```
-
-Behavior to mock server is added through interactions. Learn more about it at [Mock Server](mock-server.md)
-
-----
-
-<a href="#/pactum" >
-  <img src="https://img.shields.io/badge/PREV-Home-orange" alt="Home" align="left" style="display: inline;" />
-</a>
-<a href="#/test-runners" >
-  <img src="https://img.shields.io/badge/NEXT-Test%20Runners-blue" alt="Test Runners" align="right" style="display: inline;" />
-</a>
diff --git a/docs/reporting.md b/docs/reporting.md
deleted file mode 100644
index bcc296d..0000000
--- a/docs/reporting.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# Reporting
-
-For the tests we run through pactum can also generate reports. By default, pactum comes with zero reporters. We need to manually add & enable required reporters.
-
-## Adding a Reporter
-
-Reporters are available as individual packages. Install the required reporter as your dependency.
-
-```shell
-npm install --save-dev pactum-json-reporter
-```
-
-We can add *n* number of reporters to the pactum tests. Use `pactum.reporter.add` method to add reporters at the beginning of your execution. Run `pactum.reporter.end` method at the end of your test execution.
-
-!> As pactum is not tightly coupled with any of the test runners, it is required to run the `reporter.end()` function at the end of your test execution to let pactum generate the reports. 
-
-```js
-const pjr = require('pactum-json-reporter');
-const pactum = require('pactum');
-const reporter = pactum.reporter;
-
-// global before block
-before(() => {
-  reporter.add(pjr);
-});
-
-// global after block
-after(() => {
-  return reporter.end();
-});
-```
-
-## Available Reporters
-
-* [pactum-json-reporter](https://www.npmjs.com/package/pactum-json-reporter)
-* [pactum-swagger-coverage](https://www.npmjs.com/package/pactum-swagger-coverage)
-* [pactum-influxdb-reporter](https://www.npmjs.com/package/pactum-influxdb-reporter)
-
-?> More reporters are on the way
-
-## Write a Custom Reporter
-
-A reporter should have the following methods in it.
-
-* `afterSpec` - will be called after each spec
-* `afterStep` - will be called after each step in e2e testing
-* `afterTest` - will be called after each test in e2e testing
-* `end` - will be called at the end. It can return a promise.
-
-See the above reporters source code for usage examples.
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 66b470b..464f2f1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "pactum",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
diff --git a/package.json b/package.json
index c3a9f6e..3e4c573 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "pactum",
-  "version": "3.0.2",
-  "description": "REST API Testing Tool to write e2e, integration, contract & component or service level tests",
+  "version": "3.0.3",
+  "description": "REST API Testing Tool for all levels of testing in a Test Pyramid",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "files": [
@@ -45,6 +45,7 @@
     "server",
     "JSON",
     "pactum",
+    "pactumjs",
     "microservice",
     "microservices",
     "test",
@@ -53,11 +54,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/ASaiAnudeep/pactum.git"
+    "url": "https://github.com/pactumjs/pactum.git"
   },
-  "homepage": "https://asaianudeep.github.io/pactum",
+  "homepage": "https://pactumjs.github.io",
   "bugs": {
-    "url": "https://github.com/ASaiAnudeep/pactum/issues"
+    "url": "https://github.com/pactumjs/pactum/issues"
   },
   "author": "Anudeep <asa.anudeep4@gmail.com>",
   "license": "ISC",
diff --git a/src/exports/mock.d.ts b/src/exports/mock.d.ts
index fb9ae14..58452c9 100644
--- a/src/exports/mock.d.ts
+++ b/src/exports/mock.d.ts
@@ -10,7 +10,7 @@ export interface InteractionRequest {
   path: string;
   pathParams?: object;
   headers?: object;
-  query?: object;
+  queryParams?: object;
   graphQL?: GraphQLRequest;
   body?: any;
 }
@@ -19,6 +19,8 @@ export interface InteractionResponse {
   status: number;
   headers?: object;
   body?: object;
+  fixedDelay?: number;
+  randomDelay?: RandomDelay;
 }
 
 export interface RandomDelay {
@@ -26,16 +28,11 @@ export interface RandomDelay {
   max: number;
 }
 
-export interface InteractionResponseWithDelay extends InteractionResponse {
-  fixedDelay?: number;
-  randomDelay?: RandomDelay;
-}
-
 export interface OnCall {
-  [key: number]: InteractionResponseWithDelay
+  [key: number]: InteractionResponse
 }
 
-export interface InteractionResponse extends InteractionResponseWithDelay {
+export interface InteractionResponse {
   onCall?: OnCall
 }
 
diff --git a/src/exports/reporter.d.ts b/src/exports/reporter.d.ts
index 54b63cf..8a94f81 100644
--- a/src/exports/reporter.d.ts
+++ b/src/exports/reporter.d.ts
@@ -1,4 +1,4 @@
-import { InteractionRequest, InteractionResponse } from './mock';
+import { InteractionRequest, InteractionResponse, Interaction } from './mock';
 
 export interface SpecRequest {
   method: string;
@@ -28,8 +28,8 @@ export interface InteractionCall {
 }
 
 export interface Interaction {
-  withRequest: InteractionRequest;
-  willRespondWith: InteractionResponse;
+  request: InteractionRequest;
+  response: InteractionResponse;
   calls: InteractionCall[];
 }
 
@@ -47,6 +47,7 @@ export interface Reporter {
   afterSpec(data: SpecData): void;
   afterStep(data: object): void;
   afterTest(data: object): void;
+  afterInteraction(data: Interaction): void;
   end(): void | Promise<void>
 }
 
diff --git a/src/exports/reporter.js b/src/exports/reporter.js
index 916923e..0a38289 100644
--- a/src/exports/reporter.js
+++ b/src/exports/reporter.js
@@ -22,9 +22,14 @@ const reporter = {
     reporters.forEach(rpt => { if (rpt['afterTest']) rpt.afterTest(data); });
   },
 
+  afterInteraction(data) {
+    reporters.forEach(rpt => { if (rpt['afterInteraction']) rpt.afterInteraction(data); });
+  },
+
   async end() {
     for (let i = 0; i < reporters.length; i++) {
-      await reporters[i].end();
+      const rpt = reporters[i];
+      if (rpt['end']) await rpt.end();
     }
   }
 
diff --git a/src/helpers/reporter.lifeCycle.js b/src/helpers/reporter.lifeCycle.js
index a2d95fc..31c7bc0 100644
--- a/src/helpers/reporter.lifeCycle.js
+++ b/src/helpers/reporter.lifeCycle.js
@@ -20,8 +20,10 @@ const rlc = {
         url: spec._request.url,
         method: spec._request.method,
         path: spec._request.path,
+        pathParams: spec._request.pathParams,
+        queryParams: spec._request.queryParams,
         headers: spec._request.headers,
-        body: spec._request.data
+        body: spec._request.body
       };
       if (spec._response) {
         data.response = {
@@ -59,6 +61,10 @@ const rlc = {
       };
       reporter.afterTest(data);
     }
+  },
+
+  afterInteraction(interaction) {
+    reporter.afterInteraction(interaction);
   }
 
 };
diff --git a/src/index.js b/src/index.js
index ca2c024..bbea544 100644
--- a/src/index.js
+++ b/src/index.js
@@ -29,6 +29,7 @@ const pactum = {
   },
 
   flow(name) {
+    if (typeof name !== 'string' || !name) throw `Invalid flow name`;
     const spec = new Spec();
     spec.flow = name;
     return spec;
diff --git a/src/models/Tosser.js b/src/models/Tosser.js
index 55649fe..994013f 100644
--- a/src/models/Tosser.js
+++ b/src/models/Tosser.js
@@ -107,6 +107,7 @@ class Tosser {
     if (this.mockIds.length > 0) {
       this.interactions.length = 0;
       this.interactions = this.interactions.concat(await mock.getInteraction(this.mockIds));
+      this.spec.interactions = this.interactions;
     }
   }
 
diff --git a/src/models/server.js b/src/models/server.js
index 6c3d1fa..8731d8d 100644
--- a/src/models/server.js
+++ b/src/models/server.js
@@ -5,13 +5,15 @@ const helper = require('../helpers/helper');
 const utils = require('../helpers/utils');
 const log = require('../helpers/logger');
 const hr = require('../helpers/handler.runner');
+const rlc = require('../helpers/reporter.lifeCycle');
+const reporter = require('../exports/reporter');
 const config = require('../config');
 
 class Server {
 
   constructor() {
     this.app = null;
-    this.interactions =  new Map();
+    this.interactions = new Map();
   }
 
   start() {
@@ -122,6 +124,7 @@ function sendInteractionFoundResponse(req, res, interaction) {
   }
   interaction.callCount += 1;
   updateCalls(req, interaction);
+  rlc.afterInteraction(interaction);
 }
 
 function updateCalls(req, interaction) {
@@ -202,6 +205,9 @@ function registerPactumRemoteRoutes(server) {
       case '/api/pactum/interactions':
         handleRemoteInteractions(req, res, server);
         break;
+      case '/api/pactum/reporter/end':
+        handlerRemoteReporterEnd(res);
+        break;
       default:
         res.writeHead(404, { "Content-Type": "text/plain" });
         res.write("404 Not Found\n");
@@ -281,12 +287,27 @@ function handleRemoteInteractions(req, res, server) {
         break;
     }
   } catch (error) {
-    log.error(`Error handling remote interaction - ${error}`);
-    res.status(400);
-    res.send({ error: error.message });
+    handlerError('Error handling remote interaction', error, res);
   }
 }
 
+async function handlerRemoteReporterEnd(res) {
+  res = new ExpressResponse(res);
+  try {
+    await reporter.end();
+    res.status(200);
+    res.send({ message: 'Done' });
+  } catch (error) {
+    handlerError('Error running reporter end', error, res);
+  }
+}
+
+function handlerError(message, error, res) {
+  log.error(message, error);
+  res.status(500);
+  res.send({ error });
+}
+
 function bodyParser(req, res, next) {
   let body = '';
   req.on('data', (chunk) => {


Test patch:
diff --git a/docs/api-testing.md b/docs/api-testing.md
deleted file mode 100644
index 7490eb4..0000000
--- a/docs/api-testing.md
+++ /dev/null
@@ -1,862 +0,0 @@
-# API Testing
-
-API Testing in general can greatly improve the efficiency of our testing strategy helping us to deliver software faster than ever. It has many aspects but generally consists of making a request & validating the response. 
-
-> This documentation majorly focuses on how to make a request & how to validate the received response using *pactum*.
-
-## Request Making
-
-### spec
-
-`pactum.spec()` will return an instance of *spec* which can be used to build the request and expectations.
-
-```javascript
-const pactum = require('pactum');
-
-it('<test-name>', async () => {
-  await pactum.spec()
-    .get('http://httpbin.org/status/200');
-});
-```
-
-To pass additional parameters to the request, we can chain or use the following methods individually to build our request.
-
-| Method                    | Description                               |
-| ------------------------- | ----------------------------------------- |
-| `withPathParams`          | request path parameters                   |
-| `withQueryParams`         | request query parameters                  |
-| `withHeaders`             | request headers                           |
-| `withBody`                | request body                              |
-| `withJson`                | request json object                       |
-| `withGraphQLQuery`        | graphQL query                             |
-| `withGraphQLVariables`    | graphQL variables                         |
-| `withForm`                | object to send as form data               |
-| `withMultiPartFormData`   | object to send as multi part form data    |
-| `withRequestTimeout`      | sets request timeout                      |
-| `withCore`                | http request options                      |
-| `withAuth`                | basic auth details                        |
-| `withFollowRedirects`     | sets follow redirect boolean property     |
-| `inspect`                 | prints request & response details         |
-| `__setLogLevel`           | sets log level for troubleshooting        |
-| `toss` (optional)         | runs the spec & returns a promise         |
-
-### Request Method
-
-The request method indicates the method to be performed on the resource identified by the given Request-URI.
-
-```javascript
-const pactum = require('pactum');
-
-it('GET /user', async () => {
-  await pactum.spec()
-    .get('http://domain.com/user');
-});
-
-it('POST /user', async () => {
-  await pactum.spec()
-    .post('http://domain.com/user');
-});
-
-it('PUT /user', async () => {
-  await pactum.spec()
-    .put('http://domain.com/user');
-});
-
-it('PATCH /user', async () => {
-  await pactum.spec()
-    .patch('http://domain.com/user');
-});
-
-it('DELETE /user', async () => {
-  await pactum.spec()
-    .delete('http://domain.com/user');
-});
-```
-
-It is a general practice in API Testing, where we set the base url to a constant value.
-
-<!-- tabs:start -->
-
-#### ** base.test.js **
-
-```javascript
-const pactum = require('pactum');
-const request = pactum.request;
-
-before(() => {
-  request.setBaseUrl('http://localhost:3000');
-});
-```
-
-#### ** projects.test.js **
-
-```javascript
-const pactum = require('pactum');
-
-it('should have a post with id 5', async () => {
-  // request will be sent to http://localhost:3000/api/projects
-  await pactum.spec()
-    .get('/api/projects');
-});
-```
-
-<!-- tabs:end -->
-
-### Path Params
-
-Use `withPathParams` to pass path parameters to the request. We can either pass key & value or object as an argument.
-
-```javascript
-it('get random male user from India', async () => {
-  await pactum.spec()
-    .get('/api/project/{project}/repo/{repo}')
-    .withPathParams('project', 'project-name')
-    .withPathParams({
-      'repo': 'repo-name'
-    })
-    .expectStatus(200);
-});
-```
-
-### Query Params
-
-Use `withQueryParams` to pass query parameters to the request. We can either pass key & value or object as an argument.
-
-```javascript
-it('get random male user from India', async () => {
-  await pactum.spec()
-    .get('https://randomuser.me/api')
-    .withQueryParams('gender', 'male')
-    .withQueryParams({
-      'country': 'IND',
-      'age': 17
-    })
-    .expectStatus(200);
-});
-```
-
-### Headers
-
-Use `withHeaders` to pass headers to the request. We can either pass key & value or object as an argument.
-
-```javascript
-it('get all comments', async () => {
-  await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/comments')
-    .withHeaders('Authorization', 'Basic abc')
-    .withHeaders({
-      'Content-Type': 'application/json'
-    })
-    .expectStatus(200);
-});
-```
-
-It is a general practice in API Testing, where we set the default headers.
-
-<!-- tabs:start -->
-
-#### ** base.test.js **
-
-```javascript
-const pactum = require('pactum');
-const request = pactum.request;
-
-before(() => {
-  request.setBaseUrl('http://localhost:3000');
-  request.setDefaultHeaders('Authorization', 'Basic xxxxx');
-});
-```
-
-#### ** projects.test.js **
-
-```javascript
-const pactum = require('pactum');
-
-it('should have a post with id 5', async () => {
-  // request will be sent to http://localhost:3000/api/projects
-  await pactum.spec()
-    .get('/api/projects');
-});
-```
-
-<!-- tabs:end -->
-
-### Body
-
-Use `withBody` or `withJson` methods to pass the body to the request.
-
-```javascript
-it('post body', async () => {
-  await pactum.spec()
-    .post('https://jsonplaceholder.typicode.com/posts')
-    .withBody('{ "title": "foo", "content": "bar"}')
-    .expectStatus(201);
-});
-```
-
-```javascript
-it('post json object', async () => {
-  await pactum.spec()
-    .post('https://jsonplaceholder.typicode.com/posts')
-    .withJson({
-      title: 'foo',
-      body: 'bar',
-      userId: 1
-    })
-    .expectStatus(201);
-});
-```
-
-### Form Data
-
-Use `withForm` or `withMultiPartFormData` to pass form data to the request.
-
-#### withForm
-
-* Under the hood, pactum uses `phin.form`
-* `content-type` header will be auto updated to `application/x-www-form-urlencoded`
-
-```javascript 
-it('post with form', async () => {
-  await pactum.spec()
-    .post('https://httpbin.org/forms/posts')
-    .withForm({
-      title: 'foo',
-      body: 'bar',
-      userId: 1
-    })
-    .expectStatus(201);
-});
-```
-
-#### withMultiPartFormData
-
-* Under the hood it uses [form-data](https://www.npmjs.com/package/form-data)
-* `content-type` header will be auto updated to `multipart/form-data`
-
-```javascript
-it('post with multipart form data', async () => {
-  await pactum.spec()
-    .post('https://httpbin.org/forms/posts')
-    .withMultiPartFormData('file', fs.readFileSync('a.txt'), { contentType: 'application/js', filename: 'a.txt' })
-    .expectStatus(201);
-});
-```
-
-We can also directly use the form-data object.
-
-```javascript
-const form = new pactum.request.FormData();
-form.append(/* form data */);
-
-it('post with multipart form data', async () => {
-  await pactum.spec()
-    .post('https://httpbin.org/forms/posts')
-    .withMultiPartFormData(form)
-    .expectStatus(201);
-});
-```
-
-### GraphQL
-
-Use `withGraphQLQuery` or `withGraphQLVariables` to pass GraphQL data to the request. *Works for only POST requests.*
-
-```javascript
-it('post graphql query & variables', async () => {
-  await pactum.spec()
-    .post('https://jsonplaceholder.typicode.com/posts')
-    .withGraphQLQuery(
-      `
-        query HeroNameAndFriends($episode: Episode) {
-          hero(episode: $episode) {
-            name
-            friends {
-              name
-            }
-          }
-        }
-      `
-    )
-    .withGraphQLVariables({
-      "episode": "JEDI"
-    })
-    .expectStatus(201);
-});
-```
-
-### Request Timeout
-
-By default, pactum's request will timeout after 3000 ms. To increase the timeout for the current request use the `withRequestTimeout` method. **Make Sure To Increase The Test Runners Timeout As Well**
-
-
-```javascript
-it('some action that will take more time to complete', async () => {
-  // increase mocha timeout here
-  await pactum.spec()
-    .post('https://jsonplaceholder.typicode.com/posts')
-    .withJson({
-      title: 'foo',
-      body: 'bar',
-      userId: 1
-    })
-    .withRequestTimeout(5000)
-    .expectStatus(201);
-});
-```
-
-## Response Validation
-
-**pactum** allows us to validate the received responses content & as well as external interactions made by the service under test during [Component Testing](component-testing).
-
-Expectations helps us to assert the response received from the server.
-
-| Method                  | Description                               |
-| ----------------------- | ----------------------------------------- |
-| `expect`                | runs custom expect handler                |
-| `expectStatus`          | check HTTP status                         |
-| `expectHeader`          | check HTTP header key + value             |
-| `expectHeaderContains`  | check HTTP header key + partial value     |
-| `expectBody`            | check exact match of body                 |
-| `expectBodyContains`    | check body contains the value             |
-| `expectJson`            | check exact match of json                 |
-| `expectJsonAt`          | check json using **json-query**           |
-| `expectJsonLike`        | check loose match of json                 |
-| `expectJsonLikeAt`      | check json like using **json-query**      |
-| `expectJsonSchema`      | check json schema                         |
-| `expectJsonSchemaAt`    | check json schema using **json-query**    |
-| `expectJsonMatch`       | check json to match                       |
-| `expectJsonMatchAt`     | check json to match using **json-query**  |
-| `expectJsonSnapshot`    | check json to match with a snapshot       |
-| `expectResponseTime`    | check response time                       |
-| `wait`                  | wait before performing validation         |
-
-### Status & Headers & Response Time
-
-Expecting Status Code & Headers & response time from the response.
-
-```javascript
-const expect = pactum.expect;
-
-it('get post with id 1', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts/1')
-    .expectStatus(200)
-    .expectHeader('content-type', 'application/json; charset=utf-8')
-    .expectHeader('connection', /\w+/)
-    .expectHeaderContains('content-type', 'application/json')
-    .expectResponseTime(100);
-
-  expect(response).to.have.status(200);
-  expect(response).to.have.header('connection', 'close');
-});
-```
-
-### JSON
-
-Most REST APIs will return a JSON response. This library has few methods to validate a JSON response in many aspects.
-
-#### expectJson
-
-Performs deep equal.
-
-```javascript
-it('get post with id 1', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts/1')
-    .expectStatus(200)
-    .expectJson({
-      "userId": 1,
-      "id": 1,
-      "title": "some title",
-      "body": "some body"
-    });
-  
-  // Chai Style Assertions
-  // pactum.expect(response).should.have.json({});
-});
-```
-
-#### expectJsonAt
-
-Allows validation of specific part in a JSON. See [json-query](https://www.npmjs.com/package/json-query) for more usage details.
-
-* Performs deep equal or strict equal.
-* Order of items in an array does matter.
-
-```javascript
-it('get people', async () => {
-  const response = await pactum.spec()
-    .get('https://some-api/people')
-    .expectStatus(200)
-    .expectJson({
-      people: [
-        { name: 'Matt', country: 'NZ' },
-        { name: 'Pete', country: 'AU' },
-        { name: 'Mike', country: 'NZ' }
-      ]
-    })
-    .expectJsonAt('people[country=NZ].name', 'Matt')
-    .expectJsonAt('people[*].name', ['Matt', 'Pete', 'Mike']);
-});
-```
-
-#### expectJsonLike
-
-Performs partial deep equal. 
-
-* Allows Regular Expressions.
-* Allows Assert Expressions.
-* Allows Assert Handlers.
-* Order of items in an array doesn't matter.
-
-```javascript
-it('posts should have a item with title -"some title"', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts')
-    .expectStatus(200)
-    .expectJsonLike([
-      {
-        "userId": /\d+/,
-        "title": "some title"
-      }
-    ]);
-  
-  // Chai Style Assertions
-  // pactum.expect(response).should.have.jsonLike();
-  // spec.response().should.have.jsonLike();
-});
-```
-
-##### Assert Expressions
-
-Assert Expressions helps to run custom JavaScript code on a JSON that performs user defined assertions. 
-
- * Expression should contain `$V` to represent current value.
- * Expression should be a valid JavaScript code.
- * Expression should return a *boolean*.
-
-!> String containing **$V** will be automatically treated as a Assert Expression.
-
-```javascript
-it('get users', async () => {
-  await pactum.spec()
-    .get('/api/users')
-    .expectJsonLike('$V.length === 10'); // api should return an array with length 10
-    .expectJsonLike([
-      {
-        id: 'typeof $V === "string"',
-        name: 'jon',
-        age: '$V > 30' // age should be greater than 30 
-      }
-    ]);
-});
-```
-
-You are also allowed to change the default value `$V` to some other string based on your usage. *Be cautious that all the strings containing the new value will be treated as assert expressions and pactum will try to evaluate it as a javascript code*.
-
-```javascript
-pactum.settings.setAssertExpressionStrategy({ includes: '$' });
-
-it('get users', async () => {
-  await pactum.spec()
-    .get('/api/users')
-    .expectJsonLike([
-      {
-        name: 'jon',
-        age: '$ > 30' // age should be greater than 30 
-      }
-    ]);
-});
-```
-
-##### Assert Handlers
-
-Assert Handlers helps us to reuse the custom JavaScript assertion code on a JSON. With this we can easily extend the capabilities of `expectJsonLike` to solve complex assertions.
-
- * Handler name will be prefixed with `#`.
- * Handler function should return a *boolean*.
-
-!> String starting with **#** will be automatically treated as a Assert Handler. 
-
-Handlers is a powerful concept in pactum that helps to reuse different things. To add a assert handler use `handler.addAssertHandler` function.
-
-* First param will be the name of the assert handler which will be used in `expectJsonLike` to refer it.
-* Second param will be a function that accepts a context object as an argument. Context object will have `data` property that will represent the current value in JSON. It also includes optional `args` property that includes custom arguments. 
-
-```javascript
-pactum.handler.addAssertHandler('number', (ctx) => {
-  return typeof ctx.data === 'number';
-});
-
-it('get users', async () => {
-  await pactum.spec()
-    .get('/api/users')
-    .expectJsonLike([
-      {
-        id: '#number',
-        name: 'jon'
-      }
-    ]);
-});
-```
-
-Custom arguments can be passed to the handler function by using comma separated values after `:`.
-
-```javascript
-pactum.handler.addAssertHandler('type', (ctx) => {
-  return typeof ctx.data === ctx.args[0];
-});
-
-it('get users', async () => {
-  await pactum.spec()
-    .get('/api/users')
-    .expectJsonLike([
-      {
-        id: '#type:number',
-        name: 'jon'
-      }
-    ]);
-});
-```
-
-You are also allowed to change the default value `#` to some other string based on your usage. *Be cautious that all the strings starting with the new value will be treated as assert handlers*.
-
-```javascript
-pactum.settings.setAssertHandlerStrategy({ starts: '##' });
-
-it('get users', async () => {
-  await pactum.spec()
-    .get('/api/users')
-    .expectJsonLike([
-      {
-        id: '##handlerName:arg1,arg2',
-        name: 'jon'
-      }
-    ]);
-});
-```
-
-#### expectJsonLikeAt
-
-Allows validation of specific part in a JSON. See [json-query](https://www.npmjs.com/package/json-query) for more usage details.
-
-* Performs partial deep equal.
-* Allows Regular Expressions.
-* Allows Assert Expressions.
-* Allows Assert Handlers.
-* Order of items in an array doesn't matter.
-
-```javascript
-it('get people', async () => {
-  const response = await pactum.spec()
-    .get('https://some-api/people')
-    .expectStatus(200)
-    .expectJson({
-      people: [
-        { name: 'Matt', country: 'NZ' },
-        { name: 'Pete', country: 'AU' },
-        { name: 'Mike', country: 'NZ' }
-      ]
-    })
-    .expectJsonAt('people[*].name', ['Matt', 'Pete', 'Mike']);
-    .expectJsonLikeAt('people[*].name', ['Mike', 'Matt']);
-});
-```
-
-#### expectJsonSchema
-
-Allows validation of the schema of a JSON. See [json-schema](https://json-schema.org/learn/) for more usage details.
-
-```javascript
-it('get people', async () => {
-  const response = await pactum.spec()
-    .get('https://some-api/people')
-    .expectStatus(200)
-    .expectJson({
-      people: [
-        { name: 'Matt', country: 'NZ' },
-        { name: 'Pete', country: 'AU' },
-        { name: 'Mike', country: 'NZ' }
-      ]
-    })
-    .expectJsonSchema({
-      "type": "object",
-      "properties": {
-        "people": {
-          "type": "array"
-        }
-      }
-    });
-});
-```
-
-#### expectJsonSchemaAt
-
-Allows validation of the schema of a JSON at a specific place. See [json-schema](https://json-schema.org/learn/) for more usage details.
-
-```javascript
-it('get people', async () => {
-  const response = await pactum.spec()
-    .get('https://some-api/people')
-    .expectStatus(200)
-    .expectJson({
-      people: [
-        { name: 'Matt', country: 'NZ' },
-        { name: 'Pete', country: 'AU' },
-        { name: 'Mike', country: 'NZ' }
-      ]
-    })
-    .expectJsonSchemaAt('people', {
-      "type": "array"
-    });
-});
-```
-
-#### expectJsonMatch
-
-Allows validation of JSON with a set of matchers. See [Matching](matching) for more usage details.
-
-```javascript
-const { like } = require('pactum-matchers');
-
-it('get people', async () => {
-  const response = await pactum.spec()
-    .get('https://some-api/people')
-    .expectStatus(200)
-    .expectJsonMatch({
-      id: like(1),
-      name: 'jon'
-    });
-});
-```
-
-#### expectJsonMatchAt
-
-Allows validation of specific part in a JSON with a set of matchers. See [Matching](matching) for more usage details. See [json-query](https://www.npmjs.com/package/json-query) for more usage details.
-
-```javascript
-const { like } = require('pactum-matchers');
-
-it('get people', async () => {
-  const response = await pactum.spec()
-    .get('https://some-api/people')
-    .expectStatus(200)
-    .expectJsonMatchAt('people[0]', {
-      id: like(1),
-      name: 'jon'
-    });
-});
-```
-
-#### expectJsonSnapshot
-
-Snapshot testing is a type of **output comparison** which will be very useful whenever we want to make sure our API does not change unexpectedly.
-
-A typical snapshot test in pactum will fetch the api response, then compares it to a reference snapshot file stored alongside the test. The test will fail if the two snapshots do not match: either the change is unexpected, or the reference snapshot needs to be updated to the new version of the API response.
-
-If you are running the test for the first time, pactum will save the api response body at `./pactum/snapshots` directory. For the next test runs, pactum will compare the actual response with the local reference file. 
-
-A snapshot needs a name & it can be defined through `pactum.spec().name("<some name>")`.
-
-!> It is mandatory to commit the snapshot files to the version control system. 
-
-```js
-it('get people', async () => {
-  const response = await pactum.spec()
-    .name('GET_People')
-    .get('https://some-api/people')
-    .expectStatus(200)
-    .expectJsonSnapshot();
-});
-```
-
-There are high chances that our server will return response containing dynamic data like `ids` or `dates`. Not to fail the snapshot at every run, pactum provides matchers for any property in the JSON. See [Matching](matching) for more usage details.
-
-```js
-const { like } = require('pactum-matchers');
-
-it('get user mark', async () => {
-  const response = await pactum.spec()
-    .name('GET_User_Mark')
-    .get('https://some-api/user/{username}')
-    .withPathParams('username', 'Mark')
-    .expectStatus(200)
-    .expectJsonSnapshot({
-      id: like(123)
-    });
-});
-```
-
-When there is an intentional change in the API response, our snapshot test fails because the snapshot for our updated API no longer matches the snapshot artifact for this test case. To resolve this, we will need to update our snapshot artifacts. Use `updateSnapshot` method in the test case & run the test to update the snapshot.
-
-!> Remove `updateSnapshot` method from the test case after the snapshot is updated.
-
-```js
-const { like } = require('pactum-matchers');
-
-it('get user mark', async () => {
-  const response = await pactum.spec()
-    .name('GET_User_Mark')
-    .get('https://some-api/user/{username}')
-    .withPathParams('username', 'Mark')
-    .expectStatus(200)
-    .expectJsonSnapshot({
-      id: like(123)
-    })
-    .updateSnapshot();
-});
-```
-
-To change file location of snapshots, use `settings.setSnapshotDirectoryPath` method.
-
-### Custom Validations
-
-You can also add custom expect handlers to this library for making much more complicated assertions that are ideal to your requirement. You can bring your own assertion library or take advantage of popular libraries like [chai](https://www.npmjs.com/package/chai).
-
-#### AdHoc
-
-You can simply pass a function as a parameter to `expect` & then write your logic that performs assertions. A *context* object is passed to the handler function which contains *req* (request) & *res* (response) objects.
-
-```javascript
-const chai = require('chai');
-const expect = chai.expect;
-
-const pactum = require('pactum');
-const _expect = pactum.expect;
-
-it('post should have a item with title -"some title"', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts/5')
-    .expect((ctx) => {
-      const res = ctx.res;
-      _expect(res).to.have.status(200);
-      expect(res.json.title).equals('some title');
-    });
-});
-```
-
-#### Common
-
-There might be a use case where you wanted to perform the same set of assertions. For such scenarios, you can add custom expect handlers that can be used at different places. A *context* object is passed to the handler function which contains *req* (request) & *res* (response) objects & *data* (custom data).
-
-```javascript
-const chai = require('chai');
-const expect = chai.expect;
-
-const pactum = require('pactum');
-const _expect = pactum.expect;
-const handler = pactum.handler;
-
-before(() => {
-  handler.addExpectHandler('user details', (ctx) => {
-    const res = ctx.res;
-    const user = res.json;
-    expect(user).deep.equals({ id: 1 });
-    _expect(res).to.have.status(200);
-    _expect(res).to.have.responseTimeLessThan(500);
-    _expect(res).to.have.jsonSchema({ /* some schema */ });
-  });
-});
-
-it('should have a post with id 5', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts/5')
-    .expect('user details');
-  
-  // Chai Style Assertions
-  // pactum.expect(response).should.have._('user details');
-});
-
-it('should have a post with id 5', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts/6')
-    .expect('to have user details');
-});
-```
-
-You are also allowed to pass custom data to common expect handlers.
-
-```javascript
-before(() => {
-  handler.addExpectHandler('to have user details', (ctx) => {
-    const res = ctx.res;
-    const req = ctx.req;
-    const data = ctx.data;
-    /*
-     Add custom logic to perform based on req (request) & data (custom data passed)
-     */
-  });
-});
-
-it('should have a post with id 5', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts/5')
-    .expect('to have user details', 5); // data = 5
-});
-
-it('should have a post with id 5', async () => {
-  const response = await pactum.spec()
-    .get('https://jsonplaceholder.typicode.com/posts/6')
-    .expect('to have user details', { id: 6 }); // data = { id: 6 }
-});
-```
-
-## Request Settings
-
-This library also offers us to set default options for all the requests that are sent through it.
-
-### setBaseUrl
-
-Sets the base URL for all the HTTP requests.
-
-```javascript
-const pactum = require('pactum');
-const request = pactum.request;
-
-before(() => {
-  request.setBaseUrl('http://localhost:3000');
-});
-
-it('should have a post with id 5', async () => {
-  // request will be sent to http://localhost:3000/api/projects
-  await pactum.spec()
-    .get('/api/projects');
-});
-```
-
-### setDefaultTimeout
-
-Sets the default timeout for all the HTTP requests.
-The default value is **3000 ms**
-
-```javascript
-pactum.request.setDefaultTimeout(5000);
-```
-
-### setDefaultHeaders
-
-Sets default headers for all the HTTP requests.
-
-```javascript
-pactum.request.setDefaultHeaders('Authorization', 'Basic xxxxx');
-pactum.request.setDefaultHeaders({ 'content-type': 'application/json'});
-```
-
-### setDefaultFollowRedirects
-
-Sets default follow redirect option for HTTP requests.
-
-```javascript
-pactum.request.setDefaultFollowRedirects(true);
-```
-
-# NEXT
-
-----
-
-<a href="#/quick-start" >
-  <img src="https://img.shields.io/badge/PREV-Quick%20Start-orange" alt="Quick Start" align="left" style="display: inline;" />
-</a>
-<a href="#/integration-testing" >
-  <img src="https://img.shields.io/badge/NEXT-Integration%20Testing-blue" alt="Integration Testing" align="right" style="display: inline;" />
-</a>
diff --git a/docs/component-testing.md b/docs/component-testing.md
deleted file mode 100644
index 5dc5d08..0000000
--- a/docs/component-testing.md
+++ /dev/null
@@ -1,419 +0,0 @@
-# Component Testing
-
-Component testing is defined as a software testing type, in which the testing is performed on each component (*or service*) separately without integrating with other components (*or services*).
-
-These tests are all about testing the functionality of individual service. During this, your service will be talking to other external services. But instead of talking to real external services, they talk to mock versions of external services.
-
-It involves testing a service in isolation by 
-
-* starting a mock server locally
-* starting the service under test locally by updating the configuration of it to point the mock server for all external calls.
-* if the service is dependent on a database, start it & connect it to your service.
-
-## Pre Requisite
-
-* [API Testing](api-testing)
-* [Integration Testing](integration-testing)
-* [Mock Server](mock-server)
-
-## Example
-
-To better understand component testing, consider an e-commerce application that has multiple micro-services that power it.
-
-Assume it has a **order-service** that manages orders. When a user places an order, it will internally communicates with the **inventory-service** to check if the product is available or not. 
-
-We can write two simple functional tests for *order-service*
-
-* Buy a product which is in-stock
-* Buy a product which is out-of-stock
-
-
-*order-service* has an API endpoint `/api/orders` that accepts a POST request with the following JSON with product details for placing an order.
-
-```json
-{
-  "Name": "iPhone X",
-  "Quantity": 2
-}
-```
-
-*inventory-service* exposes an API endpoint `/api/inventory` that returns available products in the inventory. When requested, it will return the product availability details in the form of following JSON
-
-```json
-{
-  "InStock": true
-}
-```
-
-When user places an order, *order-service* will make a GET request to `/api/inventory?product=iPhone`. Based on the response from the *inventory-service*, it will accept or reject an order.
-
-Assume we have a mock server that returns a successful response for product - *iPhone* & unsuccessful response for product - *Galaxy*.
-
-If the mock server is written in **express** the internal code for mock server will look like
-
-```javascript
-const app = require('express')();
-
-app.get('/api/inventory', (req, res) => {
-  if (req.query.product === 'iPhone') {
-    res.send({ InStock = true });
-  } else {
-    res.send({ InStock = false });
-  }
-});
-
-app.listen(4000, () => {});
-```
-
-Lets look at the component tests.
-
-```javascript
-it('should buy a product which is in stock', () => {
-  await pactum.spec()
-    .post('http://localhost:3000/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(200);
-});
-
-it('should not buy a product which is out-of-stock', () => {
-  await pactum.spec()
-    .post('http://localhost:3000/api/orders')
-    .withJson({
-      "name": "Galaxy",
-      "quantity": 1
-    })
-    .expectStatus(400)
-    .expectJson({
-      "message": "product is out-of-stock"
-    });
-});
-```
-
-This looks simple & easy to test. But as the functionality of the application grows, the dependency of the *order-service* on other services will increase. To test different scenarios, it becomes difficult to control the behavior of mock server.
-
-## Simple Component Tests
-
-**pactum** makes component testing easy & fun as it allows us to control the behavior of the mock server for each & every test case. It works on top of [API Testing](api-testing) & [Mock Server](mock-server). If you haven't read about them, use the above links to learn more about them.
-
-Instead of maintaining a separate mock server, pactum comes with it. Interactions can be added to the mock server before the execution of a test case through `useInteraction` method. Once the interactions are added, you can build your request & expectations on top of it.
-
-* Interactions added through `useInteraction` method are auto removed from the mock server.
-* If interactions added through `useInteraction` method are not exercised, *pactum* will immediately fail the test case.
-
-<!-- tabs:start -->
-
-#### ** base.spec.js **
-
-```js
-const { mock } = require('pactum');
-
-before(async () => {
-  await mock.start(4000);
-});
-
-after(async () => {
-  await mock.stop();
-});
-```
-
-#### ** orders.spec.js **
-
-```js
-const pactum = require('pactum');
-
-it('should buy a product which is in stock', async () => {
-  await pactum.spec()
-    .useInteraction({
-      request: {
-        method: 'GET',
-        path: '/api/inventory',
-        queryParams: {
-          product: 'iPhone'
-        }
-      },
-      response: {
-        status: 200,
-        body: {
-          "InStock": true
-        }
-      }
-    })
-    .post('/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(200);
-});
-
-it('should not buy a product which is out-of-stock', async () => {
-  await pactum.spec()
-    .useInteraction({
-      request: {
-        method: 'GET',
-        path: '/api/inventory',
-        queryParams: {
-          product: 'iPhone'
-        }
-      },
-      response: {
-        status: 200,
-        body: {
-          "InStock": false
-        }
-      }
-    })
-    .post('/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(400)
-    .expectJson({
-      "message": "product is out-of-stock"
-    });
-});
-```
-
-<!-- tabs:end -->
-
-Interaction can also contain expectations.
-
-```js
-it('should not get health', async () => {
-  await pactum.spec()
-    .useInteraction({
-      request: {
-        method: 'GET',
-        path: '/api/health'
-      },
-      response: {
-        status: 200
-      },
-      expects: {
-        exercised: false,
-        callCount: 0
-      }
-    })
-    .post('/api/orders')
-    .expectStatus(400);
-});
-```
-
-## Multiple Interactions
-
-In real-life scenarios, a single service might be dependent upon *n* number of services. You can use `useInteraction` method multiple times to add multiple interactions.
-
-* All the interactions are auto removed.
-* Test will fail, if any one of the interaction is not exercised.
-
-```javascript
-it('should not buy a product which is out-of-stock', () => {
-  await pactum.spec()
-    .useInteraction(/* one interaction details */)
-    .useInteraction(/* another interaction details */)
-    .post('/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(400)
-    .expectJson({
-      "message": "product is out-of-stock"
-    });
-});
-```
-
-## Mock Interaction Handlers
-
-There are high chances that you wanted to use the same interaction in multiple occasions. To reuse interactions, you can create separate *js* files to hold interactions & import them in your spec file. This is one way to solve the issue. But there is a better way through *mock handlers*.
-
-Mock handlers help us to reuse interactions across tests. Use `handler.addInteractionHandler` function to temporarily store an interaction & later use it in test cases.
-
-It accepts two arguments
-
-* handler name - a string to refer the interaction later
-* callback function - it should return a mock interaction
-
-While using a mock handler, you can pass custom data into it to change the behavior of the interaction. Look at the below example where we use the same interaction in both scenarios.
-
-```javascript
-const handler = pactum.handler;
-
-before(async () => {
-  handler.addInteractionHandler('get product', (ctx) => {
-    return {
-      request: {
-        method: 'GET',
-        path: '/api/inventory',
-        queryParams: {
-          product: ctx.data.product
-        }
-      },
-      response: {
-        status: 200,
-        body: {
-          "InStock": ctx.data.inStock
-        }
-      }
-    }    
-  });
-});
-
-it('should buy a product which is in stock', () => {
-  await pactum.spec()
-    .useInteraction('get product', { product: 'iPhone', inStock: true })
-    .post('/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(200);
-});
-
-it('should not buy a product which is out-of-stock', () => {
-  await pactum.spec()
-    .useInteraction('get product', { product: 'iPhone', inStock: false })
-    .post('/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(400)
-    .expectJson({
-      "message": "product is out-of-stock"
-    });
-});
-```
-
-## Non CRUD Endpoints
-
-Not all endpoints will perform CRUD operations. Some endpoints will perform some long running operations in the background even though it sends a response immediately. It becomes difficult to test how it interacts with other services in the background.
-
-This library helps to validate whether interactions are exercised or not in the background. We can also validate the number of times the interaction is exercised.
-
-Use `mock.addInteraction` to add a interaction to the server & later use `mock.getInteraction` to get interaction details & perform validations on it.
-
-Lets look at an example
-
-```javascript
-it('some background process', () => {
-  const id = mock.addInteraction('get product');
-  await pactum.spec()
-    .post('/api/process')
-    .expectStatus(202);
-  // wait for the process to complete
-  const interaction = mock.getInteraction(id);
-  expect(interaction.exercised).equals(true);
-  expect(interaction.callCount).equals(1);
-  mock.removeInteraction(id);
-});
-```
-
-We can also use `wait` method to pause the validation for the background process to complete.
-
-```javascript
-it('some background process', () => {
-  await pactum.spec()
-    .useInteraction('get product')
-    .post('/api/process')
-    .expectStatus(202)
-    .wait(1000);
-});
-```
-
-## Using Remote Mock Server
-
-For some reasons, you want the mock server to be independent of component tests & you still want the ability to control it remotely while running your api tests. This can be achieved through `mock.useRemoteServer` function. While using remote server, all the existing functions will return promises.
-
-Let's look at the below example, where we start the mock server independent of component tests.
-
-```javascript
-// server.js
-const pactum = require('pactum');
-const mock = pactum.mock;
-const handler = pactum.handler;
-
-handler.addInteractionHandler('get product', (ctx) => {
-  return {
-    request: {
-      method: 'GET',
-      path: '/api/inventory',
-      queryParams: {
-        product: ctx.data.product
-      }
-    },
-    response: {
-      status: 200,
-      body: {
-        "InStock": ctx.data.inStock
-      }
-    }    
-  }    
-});
-
-mock.start(4000);
-```
-
-Everything works as usual when adding interactions through `useInteraction` method. But methods from *mock* will return promises. 
-
-```javascript
-// test.js
-const pactum = require('pactum');
-const mock = pactum.mock;
-
-before(() => {
-  mock.useRemoteServer('http://localhost:4000');
-});
-
-it('should buy a product which is in stock', () => {
-  await pactum.spec()
-    .useInteraction('get product', { product: 'iPhone', inStock: true })
-    .post('/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(200);
-});
-
-it('should not buy a product which is out-of-stock', () => {
-  await pactum.spec()
-    .useInteraction('get product', { product: 'iPhone', inStock: false })
-    .post('/api/orders')
-    .withJson({
-      "name": "iPhone",
-      "quantity": 1
-    })
-    .expectStatus(400)
-    .expectJson({
-      "message": "product is out-of-stock"
-    });
-});
-
-it('some background process', () => {
-  const id = await mock.addInteraction('get product');
-  await pactum.spec()
-    .post('/api/process')
-    .expectStatus(202);
-  // wait for the process to complete
-  const interaction = await mock.getInteraction(id);
-  expect(interaction.exercised).equals(true);
-  expect(interaction.callCount).equals(1);
-  await mock.removeInteraction(id);
-});
-```
-
-## Next
-
-----
-
-<a href="#/mock-server" >
-  <img src="https://img.shields.io/badge/PREV-Mock%20Server-orange" alt="Mock Server" align="left" style="display: inline;" />
-</a>
-<a href="#/contract-testing" >
-  <img src="https://img.shields.io/badge/NEXT-Contract%20Testing-blue" alt="Contract Testing" align="right" style="display: inline;" />
-</a>
diff --git a/docs/consumer-testing.md b/docs/consumer-testing.md
deleted file mode 100644
index 18b6e73..0000000
--- a/docs/consumer-testing.md
+++ /dev/null
@@ -1,331 +0,0 @@
-# Consumer Testing
-
-Consumer testing is the first step in contract testing. This testing helps in building/generating contracts for consumers with its external providers.
-
-In **pactum**, consumer tests are written as a wrapper around the [component testing](component-testing).
-
-## Table of contents
-
-* [Getting Started](#getting-started)
-  * [Example Scenario](#example-scenario)
-* [API](#api)
-
-## Getting Started
-
-Before getting started with consumer testing, get familiar with [component testing](component-testing)
-
-### Example Scenario
-
-Here we have an example describing pactum consumer tests between a consumer (order-service) and its provider (product-service).
-
-To make things simple, let's assume order-service has a single order with id `1`. When requested for this order details, the order-service will fetch corresponding product details from its provider product-service.
-
-
-#### Order Service Code
-
-```javascript
-const fetch = require('node-fetch');
-const express = require('express');
-const app = express();
-
-const PRODUCT_SERVICE_URL = process.env.PRODUCT_SERVICE_URL || 'http://my-shop.com';
-
-app.get('/api/orders/1', (req, res) => {
-  // order with id "1" includes a product with id "190"
-  const productId = 190;
-  // fetches product details with id "190"
-  fetch(`${PRODUCT_SERVICE_URL}/api/products?id=${productId}`)
-    .then(product => {
-      const order = {
-        id: 1,
-        product: {
-          id: productId,
-          name: product.name
-          price: product.price
-        }
-      }
-      // responds with order details
-      res.send(order);
-    });
-});
-
-app.listen(3000, () => console.log(`Example app listening on port ${port}!`))
-```
-
-Requesting order details will result in the following response
-
-```json
-{
-  "id": 1,
-  "product": {
-    "id": 190,
-    "name": "book",
-    "price": 321.12
-  }
-}
-```
-
-#### Component Test for Order Service
-
-A general component test for order service might look like:
-
-```javascript
-const pactum = require('pactum');
-
-it('should fetch order details', async () => {
-  await pactum
-    .get('http://localhost:3000/api/orders/1')
-    .expectStatus(200)
-    .expectJson({
-      "id": 1,
-      "product": {
-        "id": 190,
-        "name": "book",
-        "price": 321.12
-      }
-    })
-    .toss();
-});
-```
-
-As described earlier, during component testing the order-service will be talking to a mock version of product-service.
-
-#### Consumer Test for Order Service
-
-During consumer testing with **pactum**, you don't need to spin up a mock server & train it to behave like product service. Pactum comes with a mock server where you can train your service on the fly to react in a specific way when a specific request is received.
-
-As you observed in consumer code, the order-service will be making the following request on product-service.
-
-```json
-Request:
---------------------------
-Method  -   GET
-Path    -   /api/products
-Query   -   id = 1
-
-Response
---------------------------
-{
-  "id": 190,
-  "name": "book",
-  "price": 321.12
-}
-```
-
-Pactum allows you to add this interaction to the mock server before running a consumer test case. And also it automatically removes all interactions after the execution of a test case.
-
-You can add a Pact Interaction by
-
-```javascript
-const pactum = require('pactum');
-
-pactum.addPactInteraction({
-  provider: 'product-service',
-  state: 'there is product with id 190',
-  uponReceiving: 'a request for product',
-  request: {
-    method: 'GET',
-    path: '/api/products',
-    query: {
-      id: 190
-    }
-  },
-  response: {
-    status: 200,
-    headers: {
-      'content-type': 'application/json'
-    },
-    body: {
-      "id": 190,
-      "name": "book",
-      "price": 321.12
-    }
-  }
-});
-```
-
-Now, while running order service you need to update order-service to talk with pactum's mock server. By default pactum mock server runs on port `9393`.
-
-A consumer test might look like
-
-```javascript
-const pactum = require('pactum');
-
-before(async () => {
-  // sets the name of the consumer
-  pactum.consumer.setConsumerName('order-service');
-  // starts the mock server on port 9393
-  await pactum.mock.start();
-});
-
-it('should fetch order details', async () => {
-  await pactum
-    .addPactInteraction({
-      provider: 'product-service',
-      state: 'there is product with id 190',
-      uponReceiving: 'a request for product',
-      request: {
-        method: 'GET',
-        path: '/api/products',
-        query: {
-          id: 190
-        }
-      },
-      response: {
-        status: 200,
-        headers: {
-          'content-type': 'application/json'
-        },
-        body: {
-          "id": 190,
-          "name": "book",
-          "price": 321.12
-        }
-      }
-    })
-    .get('http://localhost:3000/api/orders/1')
-    .expectStatus(200)
-    .expectJson({
-      "id": 1,
-      "product": {
-        "id": 190,
-        "name": "book",
-        "price": 321.12
-      }
-    })
-    .toss();
-});
-
-after(async () => {
-  // saves the contract file in ./pacts/ folder
-  pactum.consumer.save();
-  // stops the mock server
-  await pactum.mock.stop();
-
-});
-```
-
-A real application/service might be much more complex with a lot of moving parts. The service under test might be talking to multiple external services. **Pactum** allows you to specify multiple interactions in a single test case. You can add multiple pact & mock interactions in a single spec.
-
-If anyone of the interaction is not exercised, the test will fail. At the end of the test case, all these interactions will be removed from the mock server.
-
-```javascript
-await pactum
-  .addPactInteraction(`GET_PRODUCT_DETAILS_WITH_ID_1`)
-  .addPactInteraction(`POST_AUDIT_DETAILS`)
-  .addInteraction(`GET_DELIVERY_DETAILS`)
-  .get('http://localhost:3000/api/orders/1')
-  .expectStatus(200)
-  .expectJson({
-    "id": 1,
-    "product": {
-      "id": 190,
-      "name": "book",
-      "price": 321.12
-    }
-  })
-  .toss();
-```
-
-#### Publishing Contracts to Pact Broker
-
-The final step of consumer testing is to publish the contracts (pact files) to a shared location like pact-broker.
-
-```javascript
-await pactum.consumer.publish({
-  pactFilesOrDirs: ['./pacts/'],
-  pactBroker: 'http://localhost:9292',
-  consumerVersion: '1.2.3'
-});
-```
-
-## API
-
-### pactum.mock
-
-#### setDefaultPort
-Type: `Function`<br>
-
-Sets the port of the mock server to start. The default port of the server is `9393`.
-
-*This function should be called before starting the server.*
-
-```javascript
-pactum.mock.setDefaultPort(3333);
-```
-
-#### start
-Type: `Function`<br>
-
-Starts the mock server on the default/custom port.
-
-```javascript
-pactum.mock.start();
-```
-
-#### stop
-Type: `Function`<br>
-
-Stops the mock server.
-
-```javascript
-pactum.mock.stop();
-```
-
-### pactum.consumer
-
-#### setConsumerName
-Type: `Function`<br>
-
-sets the name of the consumer
-
-```javascript
-pactum.consumer.setConsumerName('order-service');
-```
-
-#### save
-Type: `Function`<br>
-
-saves all the contracts(pact files) in the specified directory
-
-```javascript
-pactum.consumer.save();
-```
-
-#### setPactFilesDirectory
-Type: `Function`<br>
-
-sets directory for saving pact files
-
-*This should be called before save()*
-
-```javascript
-pactum.consumer.setPactFilesDirectory('/path/for/saving/pact-files');
-```
-
-#### publish
-Type: `Function`<br>
-
-publish pact files to pact broker
-
-*This should be called after save()*
-
-```javascript
-pactum.consumer.publish({
-  pactFilesOrDirs: ['./pacts/'],
-  pactBroker: 'http://pact-broker',
-  pactBrokerUsername: 'username',
-  pactBrokerPassword: '********',
-  consumerVersion: '1.2.22',
-  tags: ['QA', 'DEV']
-});
-```
-
-----
-
-<a href="#/contract-testing" >
-  <img src="https://img.shields.io/badge/PREV-Contract%20Testing-orange" alt="Contract Testing" align="left" style="display: inline;" />
-</a>
-<a href="#/provider-verification" >
-  <img src="https://img.shields.io/badge/NEXT-Provider%20Verification-blue" alt="Provider Verification" align="right" style="display: inline;" />
-</a>
\ No newline at end of file
diff --git a/docs/contract-testing.md b/docs/contract-testing.md
deleted file mode 100644
index 140b097..0000000
--- a/docs/contract-testing.md
+++ /dev/null
@@ -1,71 +0,0 @@
-# Contract Testing
-
-Contract Testing is a technique for testing interactions between applications (often called as services) that communicate with each other, to ensure the messages they send or receive conform to a shared understanding that is documented in a **contract**.
-
-Contract Testing gives a way for services to enter into an agreement on how they are going to communicate with each other. Once the agreement is in place it provides a way to modify the agreement but before the change takes effect, the services need to sign off on the new contract.
-
-Learn more about contract testing at [pact.io](https://docs.pact.io)
-
-> Pactum is inspired by **pact.io**. Pactum works at the HTTP layer while pact.io works at the unit testing level.
-
-## Table of contents
-
-* [Terminology](#terminology)
-* [Workflow](#workflow)
-  * [Consumer Testing](#consumer-testing)
-  * [Provider Verification](#provider-verification)
-* [Interactions](#interactions)
-
-## Terminology
-
-* **Consumer** - An application that makes use of the functionality or data from another application to do its job.
-
-* **Provider** - An application (often called a service) that provides functionality or data for other applications to use, often via an API.
-
-* **Contract** - A contract is a documented form of shared understanding between a consumer & a provider. Pact creates this document in the form of a **JSON** file.
-
-* **Pact** - A contract between a consumer and provider is called a pact. Each pact is a collection of interactions.
-
-* **Interaction** - An individual message that combines a request sent by the consumer & minimal expected response replied by the provider.
-
-* **Minimal Expected Response** - It describes the parts of the response the consumer wants the provider to return.
-
-## Workflow
-
-Pactum follows the same workflow of [pact.io](https://docs.pact.io)
-
-Contract Testing has two steps
-
-1. Defining Consumer Expectations (**Consumer Testing**)
-2. Verifying Expectations on Provider (**Provider Verification**)
-
-### Consumer Testing
-
-Consumer Testing is performed at the consumer pipeline.
-
-During consumer testing, a consumer will generate pacts with its provider using interactions. Consumer Pact tests operate on each interaction to say *"assuming the provider returns the expected response for this request, does the consumer code correctly generate the request and handle the expected response?"*.
-
-Consumer Testing will
-
-* Generate contracts (pact files) between a consumer & its providers
-* Publishes the contract (pact files) to a shared location like [pact-broker](https://docs.pact.io/pact_broker)
-
-### Provider Verification
-
-Provider Verification is performed at the provider's pipeline.
-
-During provider verification, each request is sent to the provider, and the actual response it generates is compared with the minimal expected response described in the consumer test.
-
-Provider Verification will
-
-* Fetch contracts (pact files) between a provider & its consumers from a shared location like [pact-broker](https://docs.pact.io/pact_broker)
-* Validate each pact against the provider & publish the results.
-
-----------------------------------------------------------------------------------------------------------------
-
-<a href="#/component-testing" >
-  <img src="https://img.shields.io/badge/PREV-Component%20Testing-orange" alt="Component Testing" align="left" style="display: inline;" />
-</a>
-<a href="#/consumer-testing" >
-  <img src="https://img.shields.io/badge/NEXT-Consumer%20Testing-blue" alt="Consumer Testing" align="right" style="display: inline;" />
-</a>
\ No newline at end of file
diff --git a/docs/e2e-testing.md b/docs/e2e-testing.md
deleted file mode 100644
index 88dc629..0000000
--- a/docs/e2e-testing.md
+++ /dev/null
@@ -1,10 +0,0 @@
-# E2E Testing
-
-End-To-End testing is a software testing method that validates entire software from starting to end along with its integration with external interfaces.
-
-## Pre Requisite
-
-* [API Testing](api-testing)
-* [Integration Testing](integration-testing)
-
-Experimental - TODO
\ No newline at end of file
diff --git a/docs/fuzz-testing.md b/docs/fuzz-testing.md
deleted file mode 100644
index 4a91cdb..0000000
--- a/docs/fuzz-testing.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Fuzz Testing
-
-Fuzz testing is still in experimental phase. At the core, pactum uses [openapi-fuzzer-core](https://github.com/ASaiAnudeep/openapi-fuzzer-core) to generate requests & it partially supports swagger v2 open-api specification.
-
-## Running Fuzz Tests
-
-Running fuzz tests on a swagger endpoint.
-
-```js
-await pactum.fuzz()
-  .onSwagger('/api/swagger.json');
-```
-
-> By default, a batch of 10 requests are sent in parallel.
-
-> It expects every request responds with client error code. *( 400 >= statusCode < 500)*
-
-More Options.
-
-| Method                    | Description                               |
-| ------------------------- | ----------------------------------------- |
-| `onSwagger`               | swagger json url                          |
-| `withBatchSize`           | no. of requests to be sent in parallel    |
-| `inspect`                 | prints request & response details         |
-| `toss` (optional)         | runs all specs & returns a promise        |
\ No newline at end of file
diff --git a/docs/integration-testing.md b/docs/integration-testing.md
deleted file mode 100644
index db70cae..0000000
--- a/docs/integration-testing.md
+++ /dev/null
@@ -1,268 +0,0 @@
-# Integration Testing
-
-Integration Testing is defined as a type of testing where software modules or components are logically integrated & tested.
-
-When it comes to API Integration Testing, essentially it involves testing how multiple APIs work together. These tests doesn't necessarily build business workflows but tests integration points between single or multiple API endpoints.
-
-> This documentation majorly focuses on the features offered by **pactum** to support integration testing by chaining multiple requests & passing data between them.
-
-## Pre Requisite
-
-* [API Testing](api-testing)
-
-## Nested Dependent HTTP Calls
-
-API testing is naturally asynchronous, which can make tests complex when these tests need to be chained. **Pactum** allows us to return custom data from the response that can be passed to the next tests using [json-query](https://www.npmjs.com/package/json-query) expressions or custom handler functions.
-
-You can pass data between tests by using either `returns` or `stores` methods.
-
-### returns 
-
-Use `returns` method to return custom response from the received response JSON.
-
-#### json-query
-
-`returns` method accepts a json-query expression as the first argument.
-
-```javascript
-const pactum = require('pactum');
-
-it('should return all posts and first post should have comments', async () => {
-  const postID = await pactum.spec()
-    .get('http://jsonplaceholder.typicode.com/posts')
-    .expectStatus(200)
-    .returns('[0].id');
-  await pactum.spec()
-    .get(`http://jsonplaceholder.typicode.com/posts/${postID}/comments`)
-    .expectStatus(200);
-});
-```
-
-Use multiple `returns` to return an array of custom responses from the received JSON.
-
-```javascript
-const pactum = require('pactum');
-
-it('first & second posts should have comments', async () => {
-  const ids = await pactum.spec()
-    .get('http://jsonplaceholder.typicode.com/posts')
-    .expectStatus(200)
-    .returns('[0].id')
-    .returns('[1].id');
-  await pactum.spec()
-    .get(`http://jsonplaceholder.typicode.com/posts/${ids[0]}/comments`)
-    .expectStatus(200);
-  await pactum.spec()
-    .get(`http://jsonplaceholder.typicode.com/posts/${ids[1]}/comments`)
-    .expectStatus(200);
-});
-```
-
-#### AdHoc Handler
-
-We can also use a custom handler function to return data. A *context* object is passed to the handler function which contains *req* (request) & *res* (response) objects. 
-
-```javascript
-const pactum = require('pactum');
-
-it('should return all posts and first post should have comments', async () => {
-  const postID = await pactum.spec()
-    .get('http://jsonplaceholder.typicode.com/posts')
-    .expectStatus(200)
-    .returns((ctx) => { return ctx.res.json[0].id });
-  await pactum.spec()
-    .get(`http://jsonplaceholder.typicode.com/posts/${postID}/comments`)
-    .expectStatus(200);
-});
-```
-
-#### Common Handler
-
-We can also use a custom common handler function to return data & use it across tests. It accepts two arguments.
-
-* *Fist Argument*: Name of the handler function used to refer it later in specs.
-* *Second Argument*: A function that receives context object with request & response details. The returned value will be the output of `await pactum.spec()`. The function should be synchronous.
-
-While using the common handlers, the name should be prefixed with `#`. It can be customized using `pactum.settings.setCaptureHandlerStrategy()`.
-
-<!-- tabs:start -->
-
-#### ** base.spec.js **
-
-```js
-const pactum = require('pactum');
-const handler = pactum.handler;
-
-before(() => {
-  handler.addCaptureHandler('first post id', (ctx) => {
-    const res = ctx.res;
-    return res.json[0].id;
-  });
-});
-```
-
-#### ** other.spec.js **
-
-```js
-const pactum = require('pactum');
-
-it('should return all posts and first post should have comments', async () => {
-  const postID = await pactum.spec()
-    .get('http://jsonplaceholder.typicode.com/posts')
-    .expectStatus(200)
-    .returns('#first post id');
-  await pactum.spec()
-    .get(`http://jsonplaceholder.typicode.com/posts/${postID}/comments`)
-    .expectStatus(200);
-});
-```
-
-<!-- tabs:end -->
-
-### stores
-
-Use `stores` method to save response data under *data management* which can be referenced later in specs. This method accepts two arguments.
-
-* *FirstArgument*: Name used to refer it later in specs.
-* *SecondArgument*: **json-query** that will fetch custom response data or it can be a capture handler.
-
-```js
-handler.addCaptureHandler('GetSecondPost', (ctx) => {
-  return ctx.res.json[1];
-});
-
-await pactum.spec()
-  .get('http://jsonplaceholder.typicode.com/posts')
-  .stores('FirstPost', '[0]')
-  .stores('SecondPost', '#GetSecondPost')
-  .stores('AllPosts', '.');
-
-/*
-
-Lets say the response is
-  [
-    {
-      id: 1,
-      user: 'jon'
-    },
-    {
-      id: 2,
-      user: 'snow'
-    }
-  ]
-
-  FirstPost - will contain the first item in the response JSON
-    {
-      id: 1,
-      user: 'jon'
-    }
-
-  SecondPost - will contain the second item in the response JSON
-    {
-      id: 2,
-      user: 'snow'
-    }
-  
-  AllPosts - will have the entire JSON response.
-*/
-```
-
-To later refer the stored value, you need to use `$S{<name>}` or `$S{<name><json-query>}` as a place holder in the requests.
-
-```javascript
-// It will make a GET request to http://jsonplaceholder.typicode.com/posts/1
-await pactum.spec()
-  .get('http://jsonplaceholder.typicode.com/posts/$S{FirstPost.id}')
-  .withJson({
-    id: '$S{FirstPost.id}'
-    title: 'new title'
-  });
-});
-
-/* 
-  It will make a POST request to http://jsonplaceholder.typicode.com/posts
-  with body 
-  {
-    data: {
-      id: 2,
-      user: 'snow'
-    }     
-  }
-*/
-await pactum.spec()
-  .post('http://jsonplaceholder.typicode.com/posts')
-  .withJson({
-    data: '$S{SecondPost}'
-  });
-});
-```
-
-## Retry Mechanism
-
-Not all APIs perform simple CRUD operations. Some operations take time & for such scenarios **pactum** allows us to add custom retry handlers that will wait for specific conditions to happen before attempting to make assertions on the response. (*Make sure to update test runners default timeout*) 
-
-Use `retry` to specify your retry strategy. It accepts options object as an argument. If the strategy function returns true, it will perform the request again.
-
-### retryOptions
-
-| Property  | Type       | Description                                |
-| --------- | ---------- | ------------------------------------------ |
-| count     | `number`   | number of times to retry - defaults to 3   |
-| delay     | `number`   | delay between retries - defaults to 1000ms |
-| strategy  | `function` | retry strategy function - returns boolean  |
-| strategy  | `string`   | retry strategy handler name                | 
-
-### AdHoc Handler
-
-We can use a custom handler function to return a boolean. A *context* object is passed to the handler function which contains *req* (request) & *res* (response) objects. 
-
-```javascript
-await pactum.spec()
-  .get('/some/async/operation')
-  .retry({
-    count: 2,
-    delay: 2000,
-    strategy: ({res}) => { return res.statusCode === 202 }
-  })
-  .expectStatus(200);
-```
-
-### Common Handler
-
-We can also use a custom common handler function to return data & use it at different places.
-
-```javascript
-const pactum = require('pactum');
-const handler = pactum.handler;
-
-before(() => {
-  handler.addRetryHandler('on 404', (ctx) => {
-    const res = ctx.res;
-    if (res.statusCode === 404) {
-      return true;
-    } else {
-      return false
-    }
-  });
-});
-
-it('should get posts', async () => {
-  await pactum.spec()
-    .get('http://jsonplaceholder.typicode.com/posts')
-    .retry({
-      strategy: 'on 404'
-    })
-    .expectStatus(200);
-});
-```
-
-## Next
-
-----
-
-<a href="#/api-testing" >
-  <img src="https://img.shields.io/badge/PREV-API%20Testing-orange" alt="API Testing" align="left" style="display: inline;" />
-</a>
-<a href="#/mock-server" >
-  <img src="https://img.shields.io/badge/NEXT-Mock%20Server-blue" alt="Mock Server" align="right" style="display: inline;" />
-</a>
\ No newline at end of file
diff --git a/docs/test-runners.md b/docs/test-runners.md
deleted file mode 100644
index e09154b..0000000
--- a/docs/test-runners.md
+++ /dev/null
@@ -1,107 +0,0 @@
-# Test Runners
-
-We can integrate **pactum** with any of the test runners that support *promises* like [mocha](https://www.npmjs.com/package/mocha), [jest](https://www.npmjs.com/package/jest), [jasmine](https://www.npmjs.com/package/jasmine), [ava](https://www.npmjs.com/package/ava), [uvu](https://www.npmjs.com/package/uvu), [tap](https://www.npmjs.com/package/tap) or [cucumber](https://www.npmjs.com/package/@cucumber). Or build your own if your heart desires, **pactum** should work out of the box.
-
-The whole documentation will be using **mocha** as the test runner. See [pactum-cucumber-boilerplate](https://github.com/ASaiAnudeep/pactum-cucumber-boilerplate) for a working example on running pactum with **cucumber**.
-  
-> Before starting with **pactum**, get familiar with any of the above test runners. It will help us to write more readable & maintainable tests. 
-
-# Testing Style
-
-Tests in **pactum** are clear and comprehensive. It uses numerous descriptive methods to build your requests and expectations.
-
-Tests can be written in two styles
-
-* Chaining the request & expectations
-* Breaking the request & expectations (BDD Style)
-
-## Chaining
-
-We can build the request & expectations by chaining the descriptive methods offered by this library.
-
-```javascript
-const pactum = require('pactum');
-
-it('should have a user with name bolt', () => {
-  return pactum.spec()
-    .get('http://localhost:9393/api/users')
-    .withQueryParams('name', 'bolt')
-    .expectStatus(200)
-    .expectJson({
-      "id": 1,
-      "name": "bolt",
-      "createdAt": "2020-08-19T14:26:44.169Z"
-    })
-    .expectJsonSchema({
-      type: 'object',
-      properties: {
-        id: {
-          type: 'number'
-        }
-      }
-    })
-    .expectResponseTime(100);
-});
-```
-
-## Breaking
-
-When you want to make your tests much more clearer, you can break your spec into multiple steps. This will come into handy when integrating **pactum** with **cucumber**. See [pactum-cucumber-boilerplate](https://github.com/ASaiAnudeep/pactum-cucumber-boilerplate) for more details on pactum & cucumber integration.
-
-
-Use `pactum.spec()` to get an instance of the spec. With **spec** you can build your request & expectations in multiple steps.
-
-Once the request is built, perform the request by calling `.toss()` method and wait for the promise to resolve.
-
-**Assertions should be made after the request is performed & resolved**.
-
-Assertions should be made by either using `pactum.expect` or `spec.response()`.
-
-```javascript
-const pactum = require('pactum');
-const expect = pactum.expect;
-
-describe('should have a user with name bolt', () => {
-
-  let spec = pactum.spec();
-  let response;
-
-  it('given a user is requested', () => {
-    spec.get('http://localhost:9393/api/users');
-  });
-
-  it('with name bolt', () => {
-    spec.withQueryParams('name', 'bolt');
-  });
-
-  it('should return a response', async () => {
-    response = await spec.toss();
-  });
-
-  it('should return a status 200', () => {
-    expect(response).to.have.status(200);
-  });
-
-  it('should return a valid user', async () => {
-    spec.response().to.have.jsonLike({ name: 'snow'});
-  });
-
-  it('should return a valid user schema', async () => {
-    expect(response).to.have.jsonSchema({ type: 'object'});
-  });
-
-  it('should return response within 100 milliseconds', async () => {
-    spec.response().to.have.responseTimeLessThan(100);
-  });
-
-});
-```
-
-----
-
-<a href="#/quick-start" >
-  <img src="https://img.shields.io/badge/PREV-Quick%20Start-orange" alt="Quick Start" align="left" style="display: inline;" />
-</a>
-<a href="#/api-testing" >
-  <img src="https://img.shields.io/badge/NEXT-API%20Testing-blue" alt="API Testing" align="right" style="display: inline;" />
-</a>
\ No newline at end of file
diff --git a/test/component/flow.spec.js b/test/component/flow.spec.js
index bdb3dbf..1332006 100644
--- a/test/component/flow.spec.js
+++ b/test/component/flow.spec.js
@@ -1,4 +1,5 @@
 const pactum = require('../../src/index');
+const expect = require('chai').expect;
 
 describe('Flow', () => {
 
@@ -10,4 +11,28 @@ describe('Flow', () => {
       .toss();
   });
 
+  it('no flow name', async () => {
+    let err;
+    try {
+      await pactum.flow()
+      .get('http://localhost:9393/default/get')
+      .expectStatus(200);
+    } catch (error) {
+      err = error;
+    }
+    expect(err).not.undefined;
+  });
+
+  it('empty flow name', async () => {
+    let err;
+    try {
+      await pactum.flow('')
+      .get('http://localhost:9393/default/get')
+      .expectStatus(200);
+    } catch (error) {
+      err = error;
+    }
+    expect(err).not.undefined;
+  });
+
 });
\ No newline at end of file
diff --git a/test/component/remote.spec.js b/test/component/remote.spec.js
index 8d85177..e21bcea 100644
--- a/test/component/remote.spec.js
+++ b/test/component/remote.spec.js
@@ -197,11 +197,33 @@ describe('Remote- invalid requests', () => {
 
 describe('Remote - Health', () => {
 
-  it('publish interactions - not exercised', async () => {
+  it('get health', async () => {
     await pactum.spec()
       .get('http://localhost:9393/api/pactum/health')
       .expectStatus(200)
       .expectBody('OK');
   });
 
+});
+
+describe('Remote - Reporter', () => {
+
+  it('reporter end - no reporters', async () => {
+    await pactum.spec()
+      .post('http://localhost:9393/api/pactum/reporter/end')
+      .expectStatus(200);
+  });
+
+  it('reporter end - with reporter fails', async () => {
+    pactum.reporter.add({
+      end() {
+        throw 'Some Error';
+      }
+    });
+    await pactum.spec()
+      .post('http://localhost:9393/api/pactum/reporter/end')
+      .expectStatus(500);
+    pactum.reporter.get().length = 0;
+  });
+
 });
\ No newline at end of file
diff --git a/test/component/reporter.spec.js b/test/component/reporter.spec.js
index ef2662c..b02472b 100644
--- a/test/component/reporter.spec.js
+++ b/test/component/reporter.spec.js
@@ -6,13 +6,17 @@ const jr = {
   afterSpec() { },
   afterStep() { },
   afterTest() { },
+  afterInteraction() { },
   end() { }
 };
 
+const jrr = {};
+
 describe('Reporter', () => {
 
   before(() => {
     reporter.add(jr);
+    reporter.add(jrr);
   });
 
   describe('Specs', () => {
diff --git a/test/unit/dataProcessor.spec.js b/test/unit/dataProcessor.spec.js
index 306ce12..0dab57d 100644
--- a/test/unit/dataProcessor.spec.js
+++ b/test/unit/dataProcessor.spec.js
@@ -26,7 +26,7 @@ describe('Data Processing - Templates', () => {
       'Address': {
         'Street': 'Main'
       }
-    }
+    };
     dp.processTemplates();
     expect(dp.template).deep.equals({
       'User': {
@@ -340,7 +340,7 @@ describe('Data Processing - Actual Data - Only Templates', () => {
   });
 
   it('processData - empty object', () => {
-    let data = {}
+    let data = {};
     data = dp.processData(data);
     expect(data).deep.equals({});
   });
@@ -484,7 +484,7 @@ describe('Data Processing - Actual Data - Only Maps', () => {
   });
 
   it('processData - empty object', () => {
-    let data = {}
+    let data = {};
     data = dp.processData(data);
     expect(data).deep.equals({});
   });
diff --git a/test/unit/request.spec.js b/test/unit/request.spec.js
index 559ad79..9df28c7 100644
--- a/test/unit/request.spec.js
+++ b/test/unit/request.spec.js
@@ -63,7 +63,7 @@ describe('request', () => {
   });
 
   afterEach(() => {
-   config.request.headers = {}; 
+   config.request.headers = {};
   });
 
 });
\ No newline at end of file
diff --git a/test/unit/spec.spec.js b/test/unit/spec.spec.js
index 6a2fe3f..67b5d44 100644
--- a/test/unit/spec.spec.js
+++ b/test/unit/spec.spec.js
@@ -311,23 +311,23 @@ describe('Spec', () => {
   });
 
   it('name - Custom Name', function() {
-    let spec = new Spec();
-    spec.name('Custom Name')
+    const spec = new Spec();
+    spec.name('Custom Name');
     expect(spec._name).equals('Custom Name');
   });
 
   it('name - passing mocha context', function() {
-    let spec = new Spec(this);
+    const spec = new Spec(this);
     expect(spec._name).equals('Spec name - passing mocha context');
   });
 
   it('name - passing invalid context to spec', function() {
-    let spec = new Spec({});
+    const spec = new Spec({});
     expect(spec._name).equals('');
   });
 
   it('name - passing invalid context with test to spec', function() {
-    let spec = new Spec({ test: null });
+    const spec = new Spec({ test: null });
     expect(spec._name).equals('');
   });
 
diff --git a/test/unit/stash.spec.js b/test/unit/stash.spec.js
index f972295..bbcd54d 100644
--- a/test/unit/stash.spec.js
+++ b/test/unit/stash.spec.js
@@ -7,7 +7,7 @@ describe('Stash', () => {
   it('default path not found', () => {
     let err;
     try {
-      stash.loadData();  
+      stash.loadData();
     } catch (error) {
       err = error;
     }
@@ -17,7 +17,7 @@ describe('Stash', () => {
   it('default path not found', () => {
     let err;
     try {
-      stash.loadData('./src/index.js');  
+      stash.loadData('./src/index.js');
     } catch (error) {
       err = error;
     }