Repository: postmanlabs/postman-code-generators
Pull request #34 (2019-06-27 06:26:13)

Added shell httpie


Patch:
diff --git a/codegens/nodejs-native/lib/parseRequest.js b/codegens/nodejs-native/lib/parseRequest.js
index ce7969a..f970e0f 100644
--- a/codegens/nodejs-native/lib/parseRequest.js
+++ b/codegens/nodejs-native/lib/parseRequest.js
@@ -141,8 +141,7 @@ function parseHost (request, indentString) {
 function parsePath (request, indentString) {
     var pathArray = _.get(request, 'url.path'),
         queryArray = _.get(request.toJSON(), 'url.query'),
-        pathSnippet = indentString + '\'path\': \'/',
-        querySnippet = '';
+        pathSnippet = indentString + '\'path\': \'/';
 
     if (pathArray && pathArray.length) {
         pathSnippet += _.reduce(pathArray, function (accumalator, key) {
@@ -154,23 +153,28 @@ function parsePath (request, indentString) {
             }
             return accumalator;
         }, []).join('/');
-    }
-
-    if (queryArray && queryArray.length) {
-        const queryExists = !(_.every(queryArray, function (element) {
-            return element.disabled && element.disabled === false;
-        }));
 
-        if (queryExists) {
-            querySnippet += '?' + _.reduce(queryArray, function (accumalator, queryElement) {
-                if (!queryElement.disabled || _.get(queryElement, 'disabled') === false) {
-                    accumalator.push(`${queryElement.key}=${encodeURIComponent(sanitize(queryElement.value))}`);
-                }
-                return accumalator;
-            }, []).join('&');
+        if (queryArray && queryArray.length) {
+            const queryExists = !(_.every(queryArray, function (element) {
+                return element.disabled && element.disabled === false;
+            }));
+
+            if (queryExists) {
+                pathSnippet += '?' + _.reduce(queryArray, function (accumalator, queryElement) {
+                    if (!queryElement.disabled || _.get(queryElement, 'disabled') === false) {
+                        accumalator.push(`${queryElement.key}=${encodeURIComponent(sanitize(queryElement.value))}`);
+                    }
+                    return accumalator;
+                }, []).join('&');
+            }
         }
+
+        pathSnippet += '\'';
+    }
+    else {
+        pathSnippet += '\'';
     }
-    pathSnippet += querySnippet + '\'';
+
     return pathSnippet;
 }
 
diff --git a/codegens/php-pecl-http/package-lock.json b/codegens/php-pecl-http/package-lock.json
index 525faf1..3115676 100644
--- a/codegens/php-pecl-http/package-lock.json
+++ b/codegens/php-pecl-http/package-lock.json
@@ -1,5 +1,5 @@
 {
-  "name": "@postman/codegen-php-peclhttp",
+  "name": "@postman/codegen-php-pecl-http",
   "version": "0.1.1",
   "lockfileVersion": 1
 }
diff --git a/codegens/shell-httpie/.eslintrc b/codegens/shell-httpie/.eslintrc
new file mode 100644
index 0000000..d80fe87
--- /dev/null
+++ b/codegens/shell-httpie/.eslintrc
@@ -0,0 +1,360 @@
+{
+  "plugins": [
+    "jsdoc",
+    "security",
+    "lodash"
+  ],
+  "env": {
+    "node": true,
+    "es6": true
+  },
+  "rules": {
+    // Possible Errors
+    "for-direction": "error",
+    "getter-return": "error",
+    "no-await-in-loop": "error",
+    "no-compare-neg-zero": "error",
+    "no-cond-assign": "error",
+    "no-console": "off",
+    "no-constant-condition": "error",
+    "no-control-regex": "error",
+    "no-debugger": "error",
+    "no-dupe-args": "error",
+    "no-dupe-keys": "error",
+    "no-duplicate-case": "error",
+    "no-empty": "error",
+    "no-empty-character-class": "error",
+    "no-ex-assign": "error",
+    "no-extra-boolean-cast": "error",
+    "no-extra-parens": "off",
+    "no-extra-semi": "error",
+    "no-func-assign": "error",
+    "no-inner-declarations": "off",
+    "no-invalid-regexp": "error",
+    "no-irregular-whitespace": "error",
+    "no-obj-calls": "error",
+    "no-prototype-builtins": "off",
+    "no-regex-spaces": "error",
+    "no-sparse-arrays": "error",
+    "no-template-curly-in-string": "error",
+    "no-unexpected-multiline": "error",
+    "no-unreachable": "error",
+    "no-unsafe-finally": "error",
+    "no-unsafe-negation": "error",
+    "use-isnan": "error",
+    "valid-jsdoc": "off",
+    "valid-typeof": "error",
+
+    // Best Practices
+    "accessor-pairs": "error",
+    "array-callback-return": "off",
+    "block-scoped-var": "error",
+    "class-methods-use-this": "error",
+    "complexity": "off",
+    "consistent-return": "warn",
+    "curly": "error",
+    "default-case": "error",
+    "dot-location": ["error", "property"],
+    "dot-notation": "error",
+    "eqeqeq": "error",
+    "guard-for-in": "warn",
+    "no-alert": "error",
+    "no-caller": "error",
+    "no-case-declarations": "error",
+    "no-div-regex": "error",
+    "no-else-return": "error",
+    "no-empty-function": "error",
+    "no-empty-pattern": "error",
+    "no-eq-null": "error",
+    "no-eval": "error",
+    "no-extend-native": "error",
+    "no-extra-bind": "error",
+    "no-extra-label": "error",
+    "no-fallthrough": "error",
+    "no-floating-decimal": "error",
+    "no-global-assign": "error",
+    "no-implicit-coercion": "error",
+    "no-implicit-globals": "error",
+    "no-implied-eval": "error",
+    "no-invalid-this": "error",
+    "no-iterator": "error",
+    "no-labels": "error",
+    "no-lone-blocks": "error",
+    "no-loop-func": "error",
+    "no-magic-numbers": "off",
+    "no-multi-spaces": "error",
+    "no-multi-str": "error",
+    "no-new": "error",
+    "no-new-func": "error",
+    "no-new-wrappers": "error",
+    "no-octal": "error",
+    "no-octal-escape": "error",
+    "no-param-reassign": "off",
+    "no-proto": "error",
+    "no-redeclare": "error",
+    "no-restricted-properties": "error",
+    "no-return-assign": "error",
+    "no-return-await": "error",
+    "no-script-url": "error",
+    "no-self-assign": "error",
+    "no-self-compare": "error",
+    "no-sequences": "error",
+    "no-throw-literal": "error",
+    "no-unmodified-loop-condition": "error",
+    "no-unused-expressions": "off",
+    "no-unused-labels": "error",
+    "no-useless-call": "error",
+    "no-useless-concat": "error",
+    "no-useless-escape": "error",
+    "no-useless-return": "error",
+    "no-void": "error",
+    "no-warning-comments": "off",
+    "no-with": "error",
+    "prefer-promise-reject-errors": "error",
+    "radix": "off",
+    "require-await": "error",
+    "vars-on-top": "off",
+    "wrap-iife": "error",
+    "yoda": "error",
+
+    // Strict Mode
+    "strict": "off",
+
+    // Variables
+    "init-declarations": "off",
+    "no-catch-shadow": "error",
+    "no-delete-var": "error",
+    "no-label-var": "error",
+    "no-restricted-globals": "error",
+    "no-shadow": "off",
+    "no-shadow-restricted-names": "error",
+    "no-undef": "off",
+    "no-undef-init": "error",
+    "no-undefined": "off",
+    "no-unused-vars": "error",
+    "no-use-before-define": "error",
+
+    // Node.js and CommonJS
+    "callback-return": "error",
+    "global-require": "off",
+    "handle-callback-err": "error",
+    "no-buffer-constructor": "error",
+    "no-mixed-requires": "off",
+    "no-new-require": "off",
+    "no-path-concat": "error",
+    "no-process-env": "error",
+    "no-process-exit": "off",
+    "no-restricted-modules": "error",
+    "no-sync": "off",
+
+    // Stylistic Issues
+    "array-bracket-newline": "off",
+    "array-bracket-spacing": "off",
+    "array-element-newline": "off",
+    "block-spacing": "error",
+    "brace-style": [2, "stroustrup", { "allowSingleLine": true }],
+    "camelcase": "off",
+    "capitalized-comments": "off",
+    "comma-dangle": ["error", "never"],
+    "comma-spacing": [2, { "before": false, "after": true }],
+    "comma-style": ["error", "last"],
+    "computed-property-spacing": "error",
+    "consistent-this": "off",
+    "eol-last": "error",
+    "func-call-spacing": "error",
+    "func-name-matching": "off",
+    "func-names": "off",
+    "func-style": "off",
+    "id-blacklist": "error",
+    "id-length": "off",
+    "id-match": "error",
+    "indent": ["error", 2, {
+      "VariableDeclarator": { "var": 1, "let": 1, "const": 1 },
+      "SwitchCase": 1
+    }],
+    "jsx-quotes": ["error", "prefer-single"],
+    "key-spacing": "error",
+    "keyword-spacing": "error",
+    "line-comment-position": "off",
+    "linebreak-style": ["error", "unix"],
+    "lines-around-comment": ["error", {
+      "beforeBlockComment": true,
+      "afterBlockComment": false,
+      "beforeLineComment": false,
+      "afterLineComment": false,
+      "allowBlockStart": true,
+      "allowBlockEnd": false,
+      "allowObjectStart": true,
+      "allowObjectEnd": false,
+      "allowArrayStart": true,
+      "allowArrayEnd": false
+    }],
+    "max-depth": "error",
+    "max-len": ["error", {
+      "code": 120
+    }],
+    "max-lines": "off",
+    "max-nested-callbacks": "error",
+    "max-params": "off",
+    "max-statements": "off",
+    "max-statements-per-line": "off",
+    "multiline-ternary": "off",
+    "new-cap": "off",
+    "new-parens": "error",
+    "newline-per-chained-call": "off",
+    "no-array-constructor": "error",
+    "no-bitwise": "off",
+    "no-continue": "off",
+    "no-inline-comments": "off",
+    "no-lonely-if": "error",
+    "no-mixed-operators": "off",
+    "no-mixed-spaces-and-tabs": "error",
+    "no-multi-assign": "off",
+    "no-multiple-empty-lines": "error",
+    "no-negated-condition": "off",
+    "no-nested-ternary": "off",
+    "no-new-object": "error",
+    "no-plusplus": "off",
+    "no-restricted-syntax": "error",
+    "no-tabs": "error",
+    "no-ternary": "off",
+    "no-trailing-spaces": "error",
+    "no-underscore-dangle": "off",
+    "no-unneeded-ternary": "error",
+    "no-whitespace-before-property": "error",
+    "nonblock-statement-body-position": "error",
+    "object-curly-newline": "off",
+    "object-curly-spacing": "off",
+    "object-property-newline": "off",
+    "one-var": ["error", "always"],
+    "one-var-declaration-per-line": "error",
+    "operator-assignment": "error",
+    "operator-linebreak": ["error", "after"],
+    "padded-blocks": "off",
+    "padding-line-between-statements": "off",
+    "quote-props": "off",
+    "quotes": ["error", "single"],
+    "require-jsdoc": "warn",
+    "semi": "error",
+    "semi-spacing": "error",
+    "sort-keys": "off",
+    "sort-vars": "off",
+    "space-before-blocks": "error",
+    "space-before-function-paren": "error",
+    "space-in-parens": "error",
+    "space-infix-ops": "error",
+    "space-unary-ops": "error",
+    "spaced-comment": ["error", "always", {
+      "block": {
+        "exceptions": ["!"]
+      }
+    }],
+    "switch-colon-spacing": "error",
+    "template-tag-spacing": "error",
+    "unicode-bom": "error",
+    "wrap-regex": "error",
+
+    // ECMAScript 6
+    "arrow-body-style": ["error", "always"],
+    "arrow-parens": ["error", "always"],
+    "arrow-spacing": "error",
+    "constructor-super": "error",
+    "generator-star-spacing": "error",
+    "no-class-assign": "error",
+    "no-confusing-arrow": "error",
+    "no-const-assign": "error",
+    "no-dupe-class-members": "error",
+    "no-duplicate-imports": "error",
+    "no-new-symbol": "error",
+    "no-restricted-imports": "error",
+    "no-this-before-super": "error",
+    "no-useless-computed-key": "error",
+    "no-useless-constructor": "off",
+    "no-var": "off",
+    "object-shorthand": "off",
+    "prefer-arrow-callback": "off",
+    "prefer-const": "off",
+    "prefer-destructuring": "off",
+    "prefer-numeric-literals": "off",
+    "prefer-rest-params": "off",
+    "prefer-spread": "error",
+    "prefer-template": "off",
+    "require-yield": "error",
+    "rest-spread-spacing": "error",
+    "sort-imports": "off",
+    "symbol-description": "off",
+    "template-curly-spacing": "error",
+    "yield-star-spacing": "error",
+
+    // Lodash
+    "lodash/callback-binding": "error",
+    "lodash/collection-method-value": "warn",
+    "lodash/collection-return": "error",
+    "lodash/no-double-unwrap": "error",
+    "lodash/no-extra-args": "error",
+    "lodash/no-unbound-this": "error",
+    "lodash/unwrap": "error",
+
+    "lodash/chain-style": ["error", "as-needed"],
+    "lodash/chaining": ["error", "always", 3],
+    "lodash/consistent-compose": ["error", "flow"],
+    "lodash/identity-shorthand": ["error", "always"],
+    "lodash/import-scope": "off",
+    "lodash/matches-prop-shorthand": ["error", "always"],
+    "lodash/matches-shorthand": ["error", "always", 3],
+    "lodash/no-commit": "error",
+    "lodash/path-style": ["error", "as-needed"],
+    "lodash/prefer-compact": "error",
+    "lodash/prefer-filter": ["off", 3],
+    "lodash/prefer-flat-map": "error",
+    "lodash/prefer-invoke-map": "error",
+    "lodash/prefer-map": "error",
+    "lodash/prefer-reject": ["error", 3],
+    "lodash/prefer-thru": "error",
+    "lodash/prefer-wrapper-method": "error",
+    "lodash/preferred-alias": "off",
+    "lodash/prop-shorthand": ["error", "always"],
+
+    "lodash/prefer-constant": "off",
+    "lodash/prefer-get": ["warn", 4],
+    "lodash/prefer-includes": ["error", { "includeNative": true }],
+    "lodash/prefer-is-nil": "error",
+    "lodash/prefer-lodash-chain": "error",
+    "lodash/prefer-lodash-method": "off",
+    "lodash/prefer-lodash-typecheck": "off",
+    "lodash/prefer-matches": ["off", 3],
+    "lodash/prefer-noop": "off",
+    "lodash/prefer-over-quantifier": "warn",
+    "lodash/prefer-some": "off",
+    "lodash/prefer-startswith": "off",
+    "lodash/prefer-times": "off",
+
+    // JsDoc
+    "jsdoc/check-param-names": "error",
+    "jsdoc/check-tag-names": "off",
+    "jsdoc/check-types": "off",
+    "jsdoc/newline-after-description": "error",
+    "jsdoc/require-description-complete-sentence": "off",
+    "jsdoc/require-example": "off",
+    "jsdoc/require-hyphen-before-param-description": "off",
+    "jsdoc/require-param": "error",
+    "jsdoc/require-param-description": "off",
+    "jsdoc/require-param-type": "off",
+    "jsdoc/require-returns-description": "off",
+    "jsdoc/require-returns-type": "error",
+
+    // Security
+    "security/detect-unsafe-regex": "off",
+    "security/detect-buffer-noassert": "error",
+    "security/detect-child-process": "error",
+    "security/detect-disable-mustache-escape": "error",
+    "security/detect-eval-with-expression": "error",
+    "security/detect-no-csrf-before-method-override": "off",
+    "security/detect-non-literal-fs-filename": "off",
+    "security/detect-non-literal-regexp": "warn",
+    "security/detect-non-literal-require": "off",
+    "security/detect-object-injection": "off",
+    "security/detect-possible-timing-attacks": "error",
+    "security/detect-pseudoRandomBytes": "error"
+  }
+}
diff --git a/codegens/shell-httpie/.gitignore b/codegens/shell-httpie/.gitignore
new file mode 100644
index 0000000..f860b0a
--- /dev/null
+++ b/codegens/shell-httpie/.gitignore
@@ -0,0 +1,69 @@
+.DS_Store
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# temporarily generated file
+run.js
+
+# Prevent IDE stuff
+.idea
+.vscode
+*.sublime-*
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+.coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Typescript v1 declaration files
+typings/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+
+out/
\ No newline at end of file
diff --git a/codegens/shell-httpie/.npmignore b/codegens/shell-httpie/.npmignore
new file mode 100644
index 0000000..6159dd2
--- /dev/null
+++ b/codegens/shell-httpie/.npmignore
@@ -0,0 +1,74 @@
+### NPM Specific: Disregard recursive project files
+### ===============================================
+/.editorconfig
+/.gitmodules
+/test
+
+### Borrowed from .gitignore
+### ========================
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Prevent IDE stuff
+.idea
+.vscode
+*.sublime-*
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+.coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Typescript v1 declaration files
+typings/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+
+out/
\ No newline at end of file
diff --git a/codegens/shell-httpie/README.md b/codegens/shell-httpie/README.md
new file mode 100644
index 0000000..cfe4637
--- /dev/null
+++ b/codegens/shell-httpie/README.md
@@ -0,0 +1,40 @@
+# codegen-shell-httpie
+
+>Converts Postman-SDK Request into code snippet for shell-httpie
+
+#### Prerequisites
+To run Code-Gen, ensure that you have NodeJS >= v8. A copy of the NodeJS installable can be downloaded from https://nodejs.org/en/download/package-manager.
+
+## Using the Module
+The module will expose an object which will have property `convert` which is the function for converting the Postman-SDK request to shell-httpie code snippet.
+
+### convert function
+Convert function takes three parameters
+
+* `request` - Postman-SDK Request Object
+
+* `options` - options is an object which hsa following properties
+    * `followRedirect` - Boolean denoting whether to redirect a request
+    * `requestTimeout` - Integer denoting time after which the request will bail out in milli-seconds
+
+* `callback` - callback function with first parameter as error and second parameter as string for code snippet
+
+##### Example:
+```js
+var request = new sdk.Request('www.google.com'),  //using postman sdk to create request  
+    options = {
+        requestTimeout: 200,
+        followRedirect: true
+    };
+convert(request, options, function(error, snippet) {
+    if (error) {
+        //  handle error
+    }
+    //  handle snippet
+});
+```
+### Guidelines for using generated snippet
+
+* Since Postman-SDK Request object doesn't provide complete path of the file, it needs to be manually inserted in case of uploading a file.
+
+* This module doesn't support cookies.
\ No newline at end of file
diff --git a/codegens/shell-httpie/index.js b/codegens/shell-httpie/index.js
new file mode 100644
index 0000000..bb0a047
--- /dev/null
+++ b/codegens/shell-httpie/index.js
@@ -0,0 +1,1 @@
+module.exports = require('./lib');
diff --git a/codegens/shell-httpie/lib/index.js b/codegens/shell-httpie/lib/index.js
new file mode 100644
index 0000000..10e558b
--- /dev/null
+++ b/codegens/shell-httpie/lib/index.js
@@ -0,0 +1,4 @@
+module.exports = {
+  convert: require('./shell-httpie').convert,
+  getOptions: require('./shell-httpie').getOptions
+};
diff --git a/codegens/shell-httpie/lib/lodash.js b/codegens/shell-httpie/lib/lodash.js
new file mode 100644
index 0000000..55ea666
--- /dev/null
+++ b/codegens/shell-httpie/lib/lodash.js
@@ -0,0 +1,456 @@
+/* istanbul ignore next */
+module.exports = {
+
+  /**
+       * Checks if `value` is an empty object, array or string.
+       *
+       * Objects are considered empty if they have no own enumerable string keyed
+       * properties.
+       *
+       * Values such as strings, arrays are considered empty if they have a `length` of `0`.
+       *
+       * @param {*} value The value to check.
+       * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+       * @example
+       *
+       * isEmpty(null)
+       * // => true
+       *
+       * isEmpty(true)
+       * // => true
+       *
+       * isEmpty(1)
+       * // => true
+       *
+       * isEmpty([1, 2, 3])
+       * // => false
+       *
+       * isEmpty('abc')
+       * // => false
+       *
+       * isEmpty({ 'a': 1 })
+       * // => false
+       */
+  isEmpty: function (value) {
+    // eslint-disable-next-line lodash/prefer-is-nil
+    if (value === null || value === undefined) {
+      return true;
+    }
+    if (Array.isArray(value) || typeof value === 'string' || typeof value.splice === 'function') {
+      return !value.length;
+    }
+
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        return false;
+      }
+    }
+
+    return true;
+  },
+
+  /**
+       * Checks if `value` is `undefined`.
+       *
+       * @param {*} value The value to check.
+       * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
+       * @example
+       *
+       * isUndefined(void 0)
+       * // => true
+       *
+       * isUndefined(null)
+       * // => false
+       */
+  isUndefined: function (value) {
+    return value === undefined;
+  },
+
+  /**
+       * Checks if `func` is classified as a `Function` object.
+       *
+       * @param {*} func The value to check.
+       * @returns {boolean} Returns `true` if `func` is a function, else `false`.
+       * @example
+       *
+       * isFunction(self.isEmpty)
+       * // => true
+       *
+       * isFunction(/abc/)
+       * // => false
+       */
+  isFunction: function (func) {
+    return typeof func === 'function';
+  },
+
+  /**
+       * Converts the first character of `string` to upper case and the remaining
+       * to lower case.
+       *
+       * @param {string} [string=''] The string to capitalize.
+       * @returns {string} Returns the capitalized string.
+       * @example
+       *
+       * capitalize('FRED')
+       * // => 'Fred'
+       *
+       * capitalize('john')
+       * // => 'John'
+       */
+
+  capitalize: function (string) {
+    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+  },
+
+  /**
+       * Reduces `array` to a value which is the accumulated result of running
+       * each element in `array` thru `iteratee`, where each successive
+       * invocation is supplied the return value of the previous. If `accumulator`
+       * is not given, the first element of `array` is used as the initial
+       * value. The iteratee is invoked with four arguments:
+       * (accumulator, value, index|key, array).
+       *
+       * @param {Array} array The Array to iterate over.
+       * @param {Function} iteratee The function invoked per iteration.
+       * @param {*} [accumulator] The initial value.
+       * @returns {*} Returns the accumulated value.
+       * @example
+       *
+       * reduce([1, 2], (sum, n) => sum + n, 0)
+       * // => 3
+       *
+       */
+  reduce: function (array, iteratee, accumulator) {
+    return array.reduce(iteratee, accumulator);
+  },
+
+  /**
+       * Iterates over elements of `array`, returning an array of all elements
+       * `predicate` returns truthy for. The predicate is invoked with three
+       * arguments: (value, index, array).
+       *
+       * @param {Array} array The array to iterate over.
+       * @param {Function|object} predicate The function/object invoked per iteration.
+       * @returns {Array} Returns the new filtered array.
+       * @example
+       *
+       * const users = [
+          *   { 'user': 'barney', 'active': true },
+          *   { 'user': 'fred',   'active': false }
+          * ]
+          *
+          * filter(users, ({ active }) => active)
+          * // => object for ['barney']
+          */
+  filter: function (array, predicate) {
+    if (typeof predicate === 'function') {
+      return array.filter(predicate);
+    }
+    var key = Object.keys(predicate),
+      val = predicate[key],
+      res = [];
+    array.forEach(function (item) {
+      if (item[key] && item[key] === val) {
+        res.push(item);
+      }
+    });
+    return res;
+  },
+
+  /**
+       * The opposite of `filter` this method returns the elements of `array`
+       * that `predicate` does **not** return truthy for.
+       *
+       * @param {Array} array collection to iterate over.
+       * @param {String} predicate The String that needs to have truthy value, invoked per iteration.
+       * @returns {Array} Returns the new filtered array.
+       * @example
+       *
+       * const users = [
+          *   { 'user': 'barney', 'active': true },
+          *   { 'user': 'fred',   'active': false }
+          * ]
+          *
+          * reject(users, 'active')
+          * // => object for ['fred']
+          */
+  reject: function (array, predicate) {
+    var res = [];
+    array.forEach((object) => {
+      if (!object[predicate]) {
+        res.push(object);
+      }
+    });
+    return res;
+  },
+
+  /**
+       * Creates an array of values by running each element of `array` thru `iteratee`.
+       * The iteratee is invoked with three arguments: (value, index, array).
+       *
+       * @param {Array} array The array to iterate over.
+       * @param {Function} iteratee The function invoked per iteration.
+       * @returns {Array} Returns the new mapped array.
+       * @example
+       *
+       * function square(n) {
+          *   return n * n
+          * }
+          *
+          * map([4, 8], square)
+          * // => [16, 64]
+          */
+  map: function (array, iteratee) {
+    return array.map(iteratee);
+  },
+
+  /**
+       * Iterates over elements of `collection` and invokes `iteratee` for each element.
+       * The iteratee is invoked with three arguments: (value, index|key, collection).
+       *
+       * @param {Array|Object} collection The collection to iterate over.
+       * @param {Function} iteratee The function invoked per iteration.
+       * @returns {Array|Object} Returns `collection`.
+       * @example
+       *
+       * forEach([1, 2], value => console.log(value))
+       * // => Logs `1` then `2`.
+       *
+       * forEach({ 'a': 1, 'b': 2 }, (value, key) => console.log(key))
+       * // => Logs 'a' then 'b'
+       */
+
+  forEach: function (collection, iteratee) {
+    if (collection === null) {
+      return null;
+    }
+
+    if (Array.isArray(collection)) {
+      return collection.forEach(iteratee);
+    }
+    const iterable = Object(collection),
+      props = Object.keys(collection);
+    var index = -1,
+      key, i;
+
+    for (i = 0; i < props.length; i++) {
+      key = props[++index];
+      iteratee(iterable[key], key, iterable);
+    }
+    return collection;
+  },
+
+  /**
+       * Checks if `value` is in `collection`. If `collection` is a string, it's
+       * checked for a substring of `value`, otherwise it checks if the `value` is present
+       * as a key in a `collection` object.
+       *
+       * @param {Array|Object|string} collection The collection to inspect.
+       * @param {*} value The value to search for.
+       * @returns {boolean} Returns `true` if `value` is found, else `false`.
+       * @example
+       *
+       * _.includes([1, 2, 3], 1);
+       * // => true
+       *
+       * _.includes({ 'a': 1, 'b': 2 }, 1);
+       * // => true
+       *
+       * _.includes('abcd', 'bc');
+       * // => true
+       */
+  includes: function (collection, value) {
+    if (Array.isArray(collection) || typeof collection === 'string') {
+      return collection.includes(value);
+    }
+    for (var key in collection) {
+      if (collection.hasOwnProperty(key)) {
+        if (collection[key] === value) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },
+
+  /**
+       * Gets the size of `collection` by returning its length for array and strings.
+       * For objects it returns the number of enumerable string keyed
+       * properties.
+       *
+       * @param {Array|Object|string} collection The collection to inspect.
+       * @returns {number} Returns the collection size.
+       * @example
+       *
+       * size([1, 2, 3])
+       * // => 3
+       *
+       * size({ 'a': 1, 'b': 2 })
+       * // => 2
+       *
+       * size('pebbles')
+       * // => 7
+       */
+  size: function (collection) {
+    // eslint-disable-next-line lodash/prefer-is-nil
+    if (collection === null || collection === undefined) {
+      return 0;
+    }
+    if (Array.isArray(collection) || typeof collection === 'string') {
+      return collection.length;
+    }
+
+    return Object.keys(collection).length;
+  },
+
+  /**
+       * Converts all elements in `array` into a string separated by `separator`.
+       *
+       * @param {Array} array The array to convert.
+       * @param {string} [separator=','] The element separator.
+       * @returns {string} Returns the joined string.
+       * @example
+       *
+       * _.join(['a', 'b', 'c'], '~');
+       * // => 'a~b~c'
+       */
+  join: function (array, separator) {
+    if (array === null) {
+      return '';
+    }
+    return array.join(separator);
+  },
+
+  /**
+       * Removes trailing whitespace or specified characters from `string`.
+       *
+       * @param {string} [string=''] The string to trim.
+       * @param {string} [chars=whitespace] The characters to trim.
+       * @returns {string} Returns the trimmed string.
+       * @example
+       *
+       * trimEnd('  abc  ')
+       * // => '  abc'
+       *
+       * trimEnd('-_-abc-_-', '_-')
+       * // => '-_-abc'
+       */
+  trimEnd: function (string, chars) {
+    if (!string) {
+      return '';
+    }
+    if (string && !chars) {
+      return string.replace(/\s*$/, '');
+    }
+    chars += '$';
+    return string.replace(new RegExp(chars, 'g'), '');
+  },
+
+  /**
+       * Returns the index of the first
+       * element `predicate` returns truthy for.
+       *
+       * @param {Array} array The array to inspect.
+       * @param {Object} predicate The exact object to be searched for in the array.
+       * @returns {number} Returns the index of the found element, else `-1`.
+       * @example
+       *
+       * var users = [
+          *   { 'user': 'barney',  'active': false },
+          *   { 'user': 'fred',    'active': false },
+          *   { 'user': 'pebbles', 'active': true }
+          * ];
+          *
+          * _.findIndex(users, { 'user': 'fred', 'active': false });
+          * // => 1
+          *
+          * _.findIndex(users, {'active' : false});
+          * // => 0
+          *
+          */
+  findIndex: function (array, predicate) {
+    var length = array === null ? 0 : array.length,
+      index = -1,
+      keys = Object.keys(predicate),
+      found, i;
+    if (!length) {
+      return -1;
+    }
+    for (i = 0; i < array.length; i++) {
+      found = true;
+      // eslint-disable-next-line no-loop-func
+      keys.forEach((key) => {
+        if (!(array[i][key] && array[i][key] === predicate[key])) {
+          found = false;
+        }
+      });
+      if (found) {
+        index = i;
+        break;
+      }
+    }
+    return index;
+  },
+
+  /**
+       * Gets the value at `path` of `object`. If the resolved value is
+       * `undefined`, the `defaultValue` is returned in its place.
+       *
+       * @param {Object} object The object to query.
+       * @param {string} path The path of the property to get.
+       * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+       * @returns {*} Returns the resolved value.
+       * @example
+       *
+       * const object = { a: {b : 'c'} }
+       *
+       *
+       * get(object, 'a.b.c', 'default')
+       * // => 'default'
+       *
+       * get(object, 'a.b', 'default')
+       * // => 'c'
+       */
+  get: function (object, path, defaultValue) {
+    if (object === null) {
+      return undefined;
+    }
+    var arr = path.split('.'),
+      res = object,
+      i;
+    for (i = 0; i < arr.length; i++) {
+      res = res[arr[i]];
+      if (res === undefined) {
+        return defaultValue;
+      }
+    }
+    return res;
+  },
+
+  /**
+       * Checks if `predicate` returns truthy for **all** elements of `array`.
+       * Iteration is stopped once `predicate` returns falsey. The predicate is
+       * invoked with three arguments: (value, index, array).
+       *
+       * @param {Array} array The array to iterate over.
+       * @param {Function} predicate The function invoked per iteration.
+       * @returns {boolean} Returns `true` if all elements pass the predicate check,
+       *  else `false`.
+       * @example
+       *
+       * every([true, 1, null, 'yes'], Boolean)
+       * // => false
+       */
+  every: function (array, predicate) {
+    var index = -1,
+      length = array === null ? 0 : array.length;
+
+    while (++index < length) {
+      if (!predicate(array[index], index, array)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+};
diff --git a/codegens/shell-httpie/lib/shell-httpie.js b/codegens/shell-httpie/lib/shell-httpie.js
new file mode 100644
index 0000000..c796dbd
--- /dev/null
+++ b/codegens/shell-httpie/lib/shell-httpie.js
@@ -0,0 +1,99 @@
+var _ = require('./lodash'),
+  Helpers = require('./util/helpers');
+
+const GAP = ' ',
+  URLENCODED = 'urlencoded',
+  FORM_DATA = 'formdata',
+  RAW = 'raw';
+
+module.exports = {
+  /**
+   * Used to return options which are specific to a particular plugin
+   * 
+   * @returns {Array}
+   */
+  getOptions: function () {
+    return [];
+  },
+
+  /**
+    * Used to convert the postman sdk-request object in php-curl reuqest snippet 
+    * 
+    * @param  {Object} request - postman SDK-request object
+    * @param  {Object} options
+    * @param {Number} options.requestTimeout : time in milli-seconds after which request will bail out
+                                                (default: 0 -> never bail out)
+    * @param {Boolean} options.followRedirect : whether to allow redirects of a request
+    * @param  {Function} callback - function with parameters (error, snippet)
+    */
+  convert: function (request, options, callback) {
+    var snippet = '',
+      parsedBody,
+      parsedHeaders,
+      bodyMode,
+      timeout,
+      url = '',
+      handleRedirect = (enableRedirect) => { if (!enableRedirect) { return GAP + '--follow' + GAP; } return GAP; },
+      handleRequestTimeout = (time) => { if (time) { return '--timeout ' + (time / 1000) + GAP; } return GAP; };
+
+    // check whether options was passed or not
+    if (_.isFunction(options)) {
+      callback = options;
+      options = null;
+    }
+    else if (!_.isFunction(callback)) { // check whether callback is a function
+      throw new Error('Shell-Httpie~convert: Callback not a function');
+    }
+
+    Helpers.parseURLVariable(request);
+    url = Helpers.addHost(request) + Helpers.addPathandQuery(request);
+    timeout = options.requestTimeout || '';
+    parsedHeaders = Helpers.addHeaders(request);
+
+    // snippet construction based on the request body
+    if (request.hasOwnProperty('body')) {
+      if (request.body.hasOwnProperty('mode')) {
+        bodyMode = request.body.mode;
+        parsedBody = Helpers.getRequestBody(request.body[bodyMode], bodyMode);
+        // handling every type of content-disposition
+        switch (bodyMode) {
+          case URLENCODED:
+            snippet += 'http --ignore-stdin --form' + handleRedirect(options.followRedirect);
+            snippet += handleRequestTimeout(timeout);
+            snippet += request.method + GAP + url + ' \\\n';
+            snippet += parsedBody + (parsedHeaders ? (' \\\n' + parsedHeaders) : '');
+            break;
+
+          case FORM_DATA:
+            snippet += 'http --ignore-stdin --form' + handleRedirect(options.followRedirect);
+            snippet += handleRequestTimeout(timeout);
+            snippet += request.method + GAP + url + ' \\\n';
+            snippet += parsedBody + (parsedHeaders ? (' \\\n' + parsedHeaders) : '');
+            break;
+
+          case RAW:
+            if (parsedBody) {
+              snippet += 'printf ' + parsedBody + '| ';
+            }
+            snippet += 'http ' + handleRedirect(options.followRedirect) + handleRequestTimeout(timeout);
+            snippet += request.method + GAP + url + (parsedHeaders ? (' \\\n' + parsedHeaders) : '');
+            break;
+
+          default:
+            return callback('Shell-Httpie~convert: Not a valid Content-Type in request body', null);
+        }
+      }
+      else {
+        snippet += 'http' + handleRedirect(options.followRedirect) + handleRequestTimeout(timeout);
+        snippet += request.method + GAP + url + (parsedHeaders ? (' \\\n' + parsedHeaders) : '');
+      }
+    }
+    else { // forming a request without a body
+      snippet += 'http' + handleRedirect(options.followRedirect) + handleRequestTimeout(timeout);
+      snippet += request.method + GAP + url + (parsedHeaders ? (' \\\n' + parsedHeaders) : '');
+    }
+
+    callback(null, snippet);
+  }
+};
+
diff --git a/codegens/shell-httpie/lib/util/helpers.js b/codegens/shell-httpie/lib/util/helpers.js
new file mode 100644
index 0000000..73efe18
--- /dev/null
+++ b/codegens/shell-httpie/lib/util/helpers.js
@@ -0,0 +1,184 @@
+var Sanitize = require('./sanitize'),
+  _ = require('../lodash');
+
+const BOUNDARY_HASH = 'e4dgoae5mIkjFjfG',
+  URLENCODED = 'urlencoded',
+  FORM_DATA = 'formdata',
+  RAW = 'raw';
+  // APP_JSON = 'application/json',
+  // APP_JS = 'application/javascript',
+  // APP_XML = 'application/xml',
+  // TEXT_XML = 'text/xml',
+  // TEXT_PLAIN = 'text/plain',
+  // TEXT_HTML = 'text/html';
+
+/**
+ * Used to parse the body of the postman SDK-request and return in the desired format
+ * 
+ * @param  {Object} request - postman SDK-request object
+ * @returns {String} - request body
+ */
+module.exports = {
+
+  boundaryHash: BOUNDARY_HASH,
+  contentType: '',
+
+  // function to add headers to the shell snippet
+  // returns headerString, comprising of all headers present in the request object
+  addHeaders: function (request) {
+    var headerString = '';
+    if (request.hasOwnProperty('headers')) {
+      if (Array.isArray(request.headers.members) && request.headers.members.length) {
+        request.headers.members = _.reject(request.headers.members, 'disabled');
+        headerString = request.headers.members.map((header) => {
+          return ' ' + header.key + ':' + Sanitize.quote(header.value);
+        }).join(' \\\n');
+      }
+      else {
+        headerString = '';
+      }
+    }
+
+    if (headerString === []) {
+      return '';
+    }
+    return headerString;
+  },
+
+  /**
+   * parses host of request object and returns code snippet of nodejs native to add hostname 
+   * 
+   * @param {Object} request - Postman SDK request object
+   * @returns {String} - code snippet of nodejs native to add hostname 
+   */
+  addHost: function (request) {
+    var hostArray = _.get(request, 'url.host', []),
+      hostSnippet = '';
+
+    if (hostArray && hostArray.length) {
+      hostSnippet += _.reduce(hostArray, function (accumalator, key) {
+        accumalator.push(`${key}`);
+        return accumalator;
+      }, []).join('.');
+    }
+
+    return hostSnippet;
+  },
+
+  addPathandQuery: function (request) {
+    var pathArray = _.get(request, 'url.path'),
+      queryArray = _.get(request.toJSON(), 'url.query'),
+      pathSnippet = '/',
+      querySnippet = '';
+
+    if (pathArray && pathArray.length) {
+      pathSnippet += _.reduce(pathArray, function (accumalator, key) {
+        if (key.length) {
+          accumalator.push(`${key}`);
+        }
+        else {
+          accumalator.push('');
+        }
+        return accumalator;
+      }, []).join('/');
+    }
+
+    if (queryArray && queryArray.length) {
+      const queryExists = !(_.every(queryArray, function (element) {
+        return element.disabled && element.disabled === false;
+      }));
+
+      if (queryExists) {
+        querySnippet += ' ' + _.reduce(queryArray, function (accumalator, queryElement) {
+          if (!queryElement.disabled || _.get(queryElement, 'disabled') === false) {
+            accumalator.push(`${Sanitize.quote(queryElement.key)}==${Sanitize.quote(queryElement.value)}`);
+          }
+          return accumalator;
+        }, []).join(' ');
+      }
+    }
+    pathSnippet += querySnippet;
+    return pathSnippet;
+  },
+
+  /**
+ * parses variable of request url object and sets hostname, path and query in request object 
+ * 
+ * @param {Object} request - Postman SDK request object 
+ */
+  parseURLVariable: function (request) {
+    const variableArray = _.get(request.toJSON(), 'url.variable', []);
+
+    if (!variableArray.length) {
+      return;
+    }
+
+    variableArray.forEach(function (variableArrayElement) {
+      request.url.host.forEach(function (hostArrayElement, hostArrayElementIndex) {
+        if (hostArrayElement === ':' + variableArrayElement.key) {
+          request.url.host[hostArrayElementIndex] = variableArrayElement.value;
+        }
+      });
+
+      request.url.path.forEach(function (pathArrayElement, pathArrayElementIndex) {
+        if (pathArrayElement === ':' + variableArrayElement.key) {
+          request.url.path[pathArrayElementIndex] = variableArrayElement.value;
+        }
+      });
+
+      request.toJSON().url.query.forEach(function (queryArrayElement, queryArrayElementIndex) {
+        if (queryArrayElement === ':' + variableArrayElement.key) {
+          request.url.query[queryArrayElementIndex] = variableArrayElement.value;
+        }
+      });
+    });
+  },
+
+  getRequestBody: function (requestBody, contentCategory) {
+    var parsedBody;
+
+    switch (contentCategory) {
+      case URLENCODED:
+        if (Array.isArray(requestBody.members) && requestBody.members.length) {
+          parsedBody = requestBody.members.map((param) => {
+            if (typeof param.value === 'string') {
+              return ' ' + Sanitize.quote(param.key) + '=' + Sanitize.quote(param.value);
+            }
+            return ' ' + param.key + ':=' + param.value;
+          }).join(' \\\n');
+        }
+        else {
+          parsedBody = '';
+        }
+        break;
+
+      case FORM_DATA:
+        if (Array.isArray(requestBody.members) && requestBody.members.length) {
+          parsedBody = requestBody.members.map((param) => {
+            if (typeof param.value === 'string') {
+              return ' ' + Sanitize.quote(param.key) + '=' + Sanitize.quote(param.value);
+            }
+            return ' ' + param.key + ':=' + param.value;
+          }).join(' \\\n');
+        }
+        else {
+          parsedBody = '';
+        }
+        break;
+
+      case RAW:
+        if (requestBody === undefined) {
+          parsedBody = '';
+        }
+        else {
+          parsedBody = requestBody ? `${Sanitize.quote(requestBody)}` : '';
+        }
+        break;
+
+      default:
+        parsedBody = '';
+    }
+
+    return parsedBody ? parsedBody : '';
+  }
+};
diff --git a/codegens/shell-httpie/lib/util/sanitize.js b/codegens/shell-httpie/lib/util/sanitize.js
new file mode 100644
index 0000000..81125e4
--- /dev/null
+++ b/codegens/shell-httpie/lib/util/sanitize.js
@@ -0,0 +1,8 @@
+module.exports = {
+  quote: function (value) {
+    if (typeof value !== 'string' || value === '') {
+      return '';
+    }
+    return '\'' + value.replace(/\\/g, '\\\\').replace(/'/g, '\'\\\'\'') + '\'';
+  }
+};
diff --git a/codegens/shell-httpie/package-lock.json b/codegens/shell-httpie/package-lock.json
new file mode 100644
index 0000000..ae748f3
--- /dev/null
+++ b/codegens/shell-httpie/package-lock.json
@@ -0,0 +1,5 @@
+{
+  "name": "@postman/codegen-shell-httpie",
+  "version": "0.1.0",
+  "lockfileVersion": 1
+}
diff --git a/codegens/shell-httpie/package.json b/codegens/shell-httpie/package.json
new file mode 100644
index 0000000..4003dfc
--- /dev/null
+++ b/codegens/shell-httpie/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "@postman/codegen-shell-httpie",
+  "version": "0.1.0",
+  "description": "Generates code snippets for a postman collection",
+  "com_postman_plugin": {
+    "type": "code_generator",
+    "lang": "shell",
+    "variant": "Httpie"
+  },
+  "main": "index.js",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "./scripts/test.sh",
+    "test-lint": "./scripts/test-lint.sh",
+    "test-unit": "./scripts/test-unit.sh",
+    "coverage": "nyc report --reporter=html --reporter=text mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "author": "Postman Labs <help@getpostman.com>",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/postmanlabs/code-generators/tree/master/codegens/shell-httpie",
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=8"
+  }
+}
diff --git a/package-lock.json b/package-lock.json
index 5c2644d..708d7a3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "postman-code-generators",
-  "version": "0.0.8",
+  "version": "0.0.7",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -161,6 +161,12 @@
         "through": ">=2.2.7 <3"
       }
     },
+    "abbrev": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz",
+      "integrity": "sha1-kbR5JYinc4wl813W9jdSovh3YTU=",
+      "dev": true
+    },
     "acorn": {
       "version": "6.1.1",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.1.1.tgz",
@@ -226,6 +232,13 @@
       "integrity": "sha512-aUjdRFISbuFOl0EIZc+9e4FfZp0bDZgAdOOf30bJmw8VM9v84SHyVyxDfbWxpGYbdZD/9XoKxfHVNmxPkhwyGw==",
       "dev": true
     },
+    "amdefine": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz",
+      "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=",
+      "dev": true,
+      "optional": true
+    },
     "ansi-escape-sequences": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/ansi-escape-sequences/-/ansi-escape-sequences-4.1.0.tgz",
@@ -410,7 +423,6 @@
       "version": "2.5.0",
       "resolved": "https://registry.npmjs.org/async/-/async-2.5.0.tgz",
       "integrity": "sha512-e+lJAJeNWuPCNyxZKOBdaJGyLGHugXVQtrAwtuAe2vhxTYxFTKE73p8JuTmdH0qdQZtDvI4dhJwjZc5zsfIsYw==",
-      "dev": true,
       "requires": {
         "lodash": "^4.14.0"
       }
@@ -495,8 +507,7 @@
     "balanced-match": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
-      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
-      "dev": true
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c="
     },
     "base": {
       "version": "0.11.2",
@@ -590,7 +601,6 @@
       "version": "1.1.11",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
       "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
       "requires": {
         "balanced-match": "^1.0.0",
         "concat-map": "0.0.1"
@@ -1271,8 +1281,7 @@
     "concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
-      "dev": true
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
     },
     "concat-stream": {
       "version": "1.5.2",
@@ -1837,6 +1846,43 @@
       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
       "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ="
     },
+    "escodegen": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.8.1.tgz",
+      "integrity": "sha1-WltTr0aTEQvrsIZ6o0MN07cKEBg=",
+      "dev": true,
+      "requires": {
+        "esprima": "^2.7.1",
+        "estraverse": "^1.9.1",
+        "esutils": "^2.0.2",
+        "optionator": "^0.8.1",
+        "source-map": "~0.2.0"
+      },
+      "dependencies": {
+        "esprima": {
+          "version": "2.7.3",
+          "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
+          "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=",
+          "dev": true
+        },
+        "estraverse": {
+          "version": "1.9.3",
+          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz",
+          "integrity": "sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=",
+          "dev": true
+        },
+        "source-map": {
+          "version": "0.2.0",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz",
+          "integrity": "sha1-2rc/vPwrqBm03gO9b26qSBZLP50=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "amdefine": ">=0.0.4"
+          }
+        }
+      }
+    },
     "eslint": {
       "version": "4.8.0",
       "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.8.0.tgz",
@@ -2429,8 +2475,7 @@
     "fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
-      "dev": true
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
     },
     "fsevents": {
       "version": "1.2.9",
@@ -3019,7 +3064,6 @@
       "version": "7.1.3",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
       "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
-      "dev": true,
       "requires": {
         "fs.realpath": "^1.0.0",
         "inflight": "^1.0.4",
@@ -3351,7 +3395,6 @@
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
       "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
-      "dev": true,
       "requires": {
         "once": "^1.3.0",
         "wrappy": "1"
@@ -3478,8 +3521,7 @@
     "interpret": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.2.0.tgz",
-      "integrity": "sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw==",
-      "dev": true
+      "integrity": "sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw=="
     },
     "invert-kv": {
       "version": "2.0.0",
@@ -3707,6 +3749,76 @@
       "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=",
       "dev": true
     },
+    "istanbul": {
+      "version": "0.4.5",
+      "resolved": "https://registry.npmjs.org/istanbul/-/istanbul-0.4.5.tgz",
+      "integrity": "sha1-ZcfXPUxNqE1POsMQuRj7C4Azczs=",
+      "dev": true,
+      "requires": {
+        "abbrev": "1.0.x",
+        "async": "1.x",
+        "escodegen": "1.8.x",
+        "esprima": "2.7.x",
+        "glob": "^5.0.15",
+        "handlebars": "^4.0.1",
+        "js-yaml": "3.x",
+        "mkdirp": "0.5.x",
+        "nopt": "3.x",
+        "once": "1.x",
+        "resolve": "1.1.x",
+        "supports-color": "^3.1.0",
+        "which": "^1.1.1",
+        "wordwrap": "^1.0.0"
+      },
+      "dependencies": {
+        "async": {
+          "version": "1.5.2",
+          "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz",
+          "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=",
+          "dev": true
+        },
+        "esprima": {
+          "version": "2.7.3",
+          "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
+          "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=",
+          "dev": true
+        },
+        "glob": {
+          "version": "5.0.15",
+          "resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz",
+          "integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=",
+          "dev": true,
+          "requires": {
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "2 || 3",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
+          }
+        },
+        "has-flag": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz",
+          "integrity": "sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=",
+          "dev": true
+        },
+        "resolve": {
+          "version": "1.1.7",
+          "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz",
+          "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=",
+          "dev": true
+        },
+        "supports-color": {
+          "version": "3.2.3",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz",
+          "integrity": "sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=",
+          "dev": true,
+          "requires": {
+            "has-flag": "^1.0.0"
+          }
+        }
+      }
+    },
     "istanbul-lib-coverage": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.5.tgz",
@@ -4392,7 +4504,6 @@
       "version": "3.0.4",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
       "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
-      "dev": true,
       "requires": {
         "brace-expansion": "^1.1.7"
       }
@@ -4665,6 +4776,15 @@
         "crypto-js": "3.1.9-1"
       }
     },
+    "nopt": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz",
+      "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=",
+      "dev": true,
+      "requires": {
+        "abbrev": "1"
+      }
+    },
     "normalize-package-data": {
       "version": "2.5.0",
       "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz",
@@ -4833,7 +4953,6 @@
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
       "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
-      "dev": true,
       "requires": {
         "wrappy": "1"
       }
@@ -5064,8 +5183,7 @@
     "path-is-absolute": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
-      "dev": true
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
     },
     "path-is-inside": {
       "version": "1.0.2",
@@ -5082,8 +5200,7 @@
     "path-parse": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
-      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
-      "dev": true
+      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw=="
     },
     "path-platform": {
       "version": "0.11.15",
@@ -5612,7 +5729,6 @@
       "version": "0.6.2",
       "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz",
       "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=",
-      "dev": true,
       "requires": {
         "resolve": "^1.1.6"
       }
@@ -5772,7 +5888,6 @@
       "version": "1.10.0",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.10.0.tgz",
       "integrity": "sha512-3sUr9aq5OfSg2S9pNtPA9hL1FVEAjvfOC4leW0SNf/mpnaakz2a9femSd6LqAww2RaFctwyf1lCqnTHuF1rxDg==",
-      "dev": true,
       "requires": {
         "path-parse": "^1.0.6"
       }
@@ -6014,7 +6129,6 @@
       "version": "0.7.8",
       "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.7.8.tgz",
       "integrity": "sha1-3svPh0sNHl+3LhSxZKloMEjprLM=",
-      "dev": true,
       "requires": {
         "glob": "^7.0.0",
         "interpret": "^1.0.0",
@@ -7270,8 +7384,7 @@
     "wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
-      "dev": true
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
     },
     "write": {
       "version": "0.2.1",
diff --git a/package.json b/package.json
index d0c3961..bb2ead0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "postman-code-generators",
-  "version": "0.0.8",
+  "version": "0.0.7",
   "description": "Generates code snippets for a postman collection",
   "main": "index.js",
   "directories": {
@@ -39,6 +39,7 @@
     "eslint-plugin-lodash": "2.4.5",
     "eslint-plugin-mocha": "4.11.0",
     "eslint-plugin-security": "1.4.0",
+    "istanbul": "0.4.5",
     "js-yaml": "3.13.1",
     "jsdoc": "3.6.2",
     "jsdoc-to-markdown": "5.0.0",


Test patch:
diff --git a/codegens/nodejs-native/test/unit/fixtures/testcollection/collection.json b/codegens/nodejs-native/test/unit/fixtures/testcollection/collection.json
index 501fce4..76b5cc6 100644
--- a/codegens/nodejs-native/test/unit/fixtures/testcollection/collection.json
+++ b/codegens/nodejs-native/test/unit/fixtures/testcollection/collection.json
@@ -129,66 +129,6 @@
       },
       "response": []
     },
-    {
-      "name": "GET Request with no path and has query params",
-      "event": [
-        {
-          "listen": "test",
-          "script": {
-            "type": "text/javascript",
-            "exec": [
-              "var responseJSON;",
-              "",
-              "try { ",
-              "    responseJSON = JSON.parse(responseBody); ",
-              "    tests['response is valid JSON'] = true;",
-              "}",
-              "catch (e) { ",
-              "    responseJSON = {}; ",
-              "    tests['response is valid JSON'] = false;",
-              "}",
-              "",
-              "tests['response json contains headers'] = _.has(responseJSON, 'headers');",
-              "tests['response json contains args'] = _.has(responseJSON, 'args');",
-              "tests['response json contains url'] = _.has(responseJSON, 'url');",
-              "",
-              "tests['args key contains argument passed as url parameter'] = ('test' in responseJSON.args);",
-              "tests['args passed via request url params has value \"123\"'] = (_.get(responseJSON, 'args.test') === \"123\");"
-            ]
-          }
-        }
-      ],
-      "request": {
-        "method": "GET",
-        "header": [],
-        "body": {},
-        "url": {
-          "raw": "https://89c918b1-f4f8-4812-8e6c-69ecbeeb8409.mock.pstmn.io?query1=1&query2=2",
-          "protocol": "https",
-          "host": [
-            "89c918b1-f4f8-4812-8e6c-69ecbeeb8409",
-            "mock",
-            "pstmn",
-            "io"
-          ],
-          "path": [],
-          "query": [
-            {
-              "key": "query1",
-              "value": "1",
-              "equals": true
-            },
-            {
-              "key": "query2",
-              "value": "2",
-              "equals": true
-            }
-          ]
-        },
-        "description": "The HTTP `GET` request method is meant to retrieve data from a server. The data\nis identified by a unique URI (Uniform Resource Identifier). \n\nA `GET` request can pass parameters to the server using \"Query String \nParameters\". For example, in the following request,\n\n> http://example.com/hi/there?hand=wave\n\nThe parameter \"hand\" has the value \"wave\".\n\nThis endpoint echoes the HTTP headers, request parameters and the complete\nURI requested."
-      },
-      "response": []
-    },
     {
       "name": "POST Raw Text",
       "event": [
diff --git a/codegens/nodejs-native/test/unit/snippet.test.js b/codegens/nodejs-native/test/unit/snippet.test.js
index 9f668d8..1a1d14e 100644
--- a/codegens/nodejs-native/test/unit/snippet.test.js
+++ b/codegens/nodejs-native/test/unit/snippet.test.js
@@ -141,43 +141,4 @@ describe('nodejs-native convert function', function () {
             });
         });
     });
-
-    it('should sustain path variables when request has no path and has query params', function () {
-        var request = new sdk.Request({
-                'method': 'GET',
-                'header': [],
-                'body': {},
-                'url': {
-                    'raw': 'https://89c918b1-f4f8-4812-8e6c-69ecbeeb8409.mock.pstmn.io?query1=1&query2=2',
-                    'protocol': 'https',
-                    'host': [
-                        '89c918b1-f4f8-4812-8e6c-69ecbeeb8409',
-                        'mock',
-                        'pstmn',
-                        'io'
-                    ],
-                    'path': [],
-                    'query': [
-                        {
-                            'key': 'query1',
-                            'value': '1',
-                            'equals': true
-                        },
-                        {
-                            'key': 'query2',
-                            'value': '2',
-                            'equals': true
-                        }
-                    ]
-                }
-            }),
-            options = {};
-        convert(request, options, function (error, snippet) {
-            if (error) {
-                expect.fail(null, null, error);
-            }
-            expect(snippet).to.be.a('string');
-            expect(snippet).to.include('\'path\': \'/?query1=1&query2=2\'');
-        });
-    });
 });
diff --git a/codegens/shell-httpie/examples/test-collection.json b/codegens/shell-httpie/examples/test-collection.json
new file mode 100644
index 0000000..b51bcfe
--- /dev/null
+++ b/codegens/shell-httpie/examples/test-collection.json
@@ -0,0 +1,1450 @@
+{
+	"info": {
+		"name": "Code-Gen Test Cases",
+		"_postman_id": "41182fad-912e-6bc9-d6b9-dfb6f5bf5ffb",
+		"description": "This collection contains requests that will be used to test validity of plugin created to convert postman request into code snippet of particular language.",
+		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+	},
+	"item": [
+		{
+			"name": "POST form data with file",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "application/x-www-form-urlencoded",
+						"disabled": false
+					},
+					{
+						"key": "content-type",
+						"value": "application/json",
+						"disabled": true
+					}
+				],
+				"body": {
+					"mode": "formdata",
+					"formdata": [
+						{
+							"key": "fdjks",
+							"value": "dsf",
+							"type": "text"
+						},
+						{
+							"key": "sdf",
+							"value": "helo",
+							"type": "text"
+						},
+						{
+							"key": "12",
+							"value": "\"23\"",
+							"description": "",
+							"type": "text"
+						},
+						{
+							"key": "'123'",
+							"value": "'\"23\\\"4\\\"\"'",
+							"description": "",
+							"type": "text"
+						}
+					]
+				},
+				"url": {
+					"raw": "https://postman-echo.com/post",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post"
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "Request Headers with disabled headers",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"try {",
+							"    tests[\"Body contains headers\"] = responseBody.has(\"headers\");",
+							"    responseJSON = JSON.parse(responseBody);",
+							"    tests[\"Header contains host\"] = \"host\" in responseJSON.headers;",
+							"    tests[\"Header contains test parameter sent as part of request header\"] = \"my-sample-header\" in responseJSON.headers;",
+							"}",
+							"catch (e) { }",
+							"",
+							"",
+							"",
+							""
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "GET",
+				"header": [
+					{
+						"key": "my-sample-header",
+						"value": "Lorem ipsum dolor sit amet"
+					},
+					{
+						"key": "not-disabled-header",
+						"value": "ENABLED"
+					},
+					{
+						"key": "disabled header",
+						"value": "DISABLED",
+						"disabled": true
+					}
+				],
+				"body": {},
+				"url": {
+					"raw": "https://postman-echo.com/headers",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"headers"
+					]
+				},
+				"description": "A `GET` request to this endpoint returns the list of all request headers as part of the response JSON.\nIn Postman, sending your own set of headers through the [Headers tab](https://www.getpostman.com/docs/requests#headers?source=echo-collection-app-onboarding) will reveal the headers as part of the response."
+			},
+			"response": []
+		},
+		{
+			"name": "GET Request with disabled query",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"tests['response json contains headers'] = _.has(responseJSON, 'headers');",
+							"tests['response json contains args'] = _.has(responseJSON, 'args');",
+							"tests['response json contains url'] = _.has(responseJSON, 'url');",
+							"",
+							"tests['args key contains argument passed as url parameter'] = ('test' in responseJSON.args);",
+							"tests['args passed via request url params has value \"123\"'] = (_.get(responseJSON, 'args.test') === \"123\");"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "GET",
+				"header": [],
+				"body": {},
+				"url": {
+					"raw": "https://postman-echo.com/get?test=123&anotherone=232",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"get"
+					],
+					"query": [
+						{
+							"key": "test",
+							"value": "123",
+							"equals": true
+						},
+						{
+							"key": "anotherone",
+							"value": "232",
+							"equals": true
+						},
+						{
+							"key": "anotheroneone",
+							"value": "sdfsdf",
+							"equals": true,
+							"disabled": true
+						}
+					]
+				},
+				"description": "The HTTP `GET` request method is meant to retrieve data from a server. The data\nis identified by a unique URI (Uniform Resource Identifier). \n\nA `GET` request can pass parameters to the server using \"Query String \nParameters\". For example, in the following request,\n\n> http://example.com/hi/there?hand=wave\n\nThe parameter \"hand\" has the value \"wave\".\n\nThis endpoint echoes the HTTP headers, request parameters and the complete\nURI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "POST Raw Text",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"id": "753f8a33-adb6-402f-8d19-386c1981ecb6",
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "\"'Duis posuere augue vel cursus pharetra. In luctus a ex nec pretium. Praesent neque quam, tincidunt nec leo eget, rutrum vehicula magna.\nMaecenas consequat elementum elit, \"id\" \"se\\\"mper\" sem tristique et. Integer pulvinar enim quis consectetur interdum volutpat.'\""
+				},
+				"url": {
+					"raw": "https://postman-echo.com/post",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post"
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "POST urlencoded data with disabled entries",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "application/x-www-form-urlencoded"
+					}
+				],
+				"body": {
+					"mode": "urlencoded",
+					"urlencoded": [
+						{
+							"key": "1",
+							"value": "a",
+							"description": "",
+							"type": "text"
+						},
+						{
+							"key": "2",
+							"value": "b",
+							"description": "",
+							"type": "text"
+						},
+						{
+							"key": "\"\"12\"\"",
+							"value": "\"23\"",
+							"description": "",
+							"type": "text"
+						},
+						{
+							"key": "'1\"2\\\"\"3'",
+							"value": "'1\"23\"4'",
+							"description": "",
+							"type": "text"
+						}
+					]
+				},
+				"url": {
+					"raw": "https://postman-echo.com/post/?hardik=\"me\"",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post",
+						""
+					],
+					"query": [
+						{
+							"key": "hardik",
+							"value": "\"me\"",
+							"equals": true
+						}
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "POST json with raw",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "application/json"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "{\n  \"json\": \"Test-Test\"\n}"
+				},
+				"url": {
+					"raw": "https://postman-echo.com/post",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post"
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": [
+				{
+					"id": "db02f994-5ac4-41e1-835a-f49a14acbb6e",
+					"name": "POST json with raw",
+					"originalRequest": {
+						"method": "POST",
+						"header": [
+							{
+								"key": "Content-Type",
+								"value": "application/json"
+							}
+						],
+						"body": {
+							"mode": "raw",
+							"raw": "{\n  \"json\": \"Test-Test\"\n}"
+						},
+						"url": {
+							"raw": "https://postman-echo.com/post",
+							"protocol": "https",
+							"host": [
+								"postman-echo",
+								"com"
+							],
+							"path": [
+								"post"
+							]
+						}
+					},
+					"status": "OK",
+					"code": 200,
+					"_postman_previewlanguage": "json",
+					"header": [
+						{
+							"key": "Access-Control-Allow-Credentials",
+							"value": "",
+							"name": "Access-Control-Allow-Credentials",
+							"description": "Indicates whether or not the response to the request can be exposed when the credentials flag is true. When used as part of a response to a preflight request, this indicates whether or not the actual request can be made using credentials."
+						},
+						{
+							"key": "Access-Control-Allow-Headers",
+							"value": "",
+							"name": "Access-Control-Allow-Headers",
+							"description": "Used in response to a preflight request to indicate which HTTP headers can be used when making the actual request."
+						},
+						{
+							"key": "Access-Control-Allow-Methods",
+							"value": "",
+							"name": "Access-Control-Allow-Methods",
+							"description": "Specifies the method or methods allowed when accessing the resource. This is used in response to a preflight request."
+						},
+						{
+							"key": "Access-Control-Allow-Origin",
+							"value": "",
+							"name": "Access-Control-Allow-Origin",
+							"description": "Specifies a URI that may access the resource. For requests without credentials, the server may specify '*' as a wildcard, thereby allowing any origin to access the resource."
+						},
+						{
+							"key": "Access-Control-Expose-Headers",
+							"value": "",
+							"name": "Access-Control-Expose-Headers",
+							"description": "Lets a server whitelist headers that browsers are allowed to access."
+						},
+						{
+							"key": "Connection",
+							"value": "keep-alive",
+							"name": "Connection",
+							"description": "Options that are desired for the connection"
+						},
+						{
+							"key": "Content-Encoding",
+							"value": "gzip",
+							"name": "Content-Encoding",
+							"description": "The type of encoding used on the data."
+						},
+						{
+							"key": "Content-Length",
+							"value": "385",
+							"name": "Content-Length",
+							"description": "The length of the response body in octets (8-bit bytes)"
+						},
+						{
+							"key": "Content-Type",
+							"value": "application/json; charset=utf-8",
+							"name": "Content-Type",
+							"description": "The mime type of this content"
+						},
+						{
+							"key": "Date",
+							"value": "Wed, 07 Feb 2018 10:06:15 GMT",
+							"name": "Date",
+							"description": "The date and time that the message was sent"
+						},
+						{
+							"key": "ETag",
+							"value": "W/\"215-u7EU1nFtauIn0/aVifjuXA\"",
+							"name": "ETag",
+							"description": "An identifier for a specific version of a resource, often a message digest"
+						},
+						{
+							"key": "Server",
+							"value": "nginx",
+							"name": "Server",
+							"description": "A name for the server"
+						},
+						{
+							"key": "Vary",
+							"value": "X-HTTP-Method-Override, Accept-Encoding",
+							"name": "Vary",
+							"description": "Tells downstream proxies how to match future request headers to decide whether the cached response can be used rather than requesting a fresh one from the origin server."
+						},
+						{
+							"key": "set-cookie",
+							"value": "sails.sid=s%3AxRBxgrc9M-jKK_l1mX3y3rM_ry8wYLz4.Of4qpOzd9hi6uO0sAQIj%2Bxs2VeppWxYjJa4OpIW3PKg; Path=/; HttpOnly",
+							"name": "set-cookie",
+							"description": "an HTTP cookie"
+						}
+					],
+					"cookie": [
+						{
+							"expires": "Tue Jan 19 2038 08:44:07 GMT+0530 (IST)",
+							"httpOnly": true,
+							"domain": "postman-echo.com",
+							"path": "/",
+							"secure": false,
+							"value": "s%3AxRBxgrc9M-jKK_l1mX3y3rM_ry8wYLz4.Of4qpOzd9hi6uO0sAQIj%2Bxs2VeppWxYjJa4OpIW3PKg",
+							"key": "sails.sid"
+						}
+					],
+					"body": "{\"args\":{},\"data\":\"{\\n  \\\"json\\\": \\\"Test-Test\\\"\\n}\",\"files\":{},\"form\":{},\"headers\":{\"host\":\"postman-echo.com\",\"content-length\":\"25\",\"accept\":\"*/*\",\"accept-encoding\":\"gzip, deflate\",\"cache-control\":\"no-cache\",\"content-type\":\"text/plain\",\"cookie\":\"sails.sid=s%3AkOgtF1XmXtVFx-Eg3S7-37BKKaMqMDPe.hnwldNwyvsaASUiRR0Y0vcowadkMXO4HMegTeVIPgqo\",\"postman-token\":\"2ced782f-a141-428e-8af6-04ce954a77d5\",\"user-agent\":\"PostmanRuntime/7.1.1\",\"x-forwarded-port\":\"443\",\"x-forwarded-proto\":\"https\"},\"json\":null,\"url\":\"https://postman-echo.com/post\"}"
+				}
+			]
+		},
+		{
+			"name": "POST javascript with raw",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "application/javascript"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "var val = 6;\nconsole.log(val);"
+				},
+				"url": {
+					"raw": "https://postman-echo.com/post",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post"
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "POST text/xml with raw",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/xml"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "<xml>\n  Test Test\n</xml>"
+				},
+				"url": {
+					"raw": "https://postman-echo.com/post",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post"
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "POST text/html with raw",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/html"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "<html>\n  Test Test\n</html>"
+				},
+				"url": {
+					"raw": "https://postman-echo.com/post",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post"
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "Resolve URL",
+			"request": {
+				"method": "POST",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "application/x-www-form-urlencoded"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "Duis posuere augue vel cursus pharetra. In luctus a ex nec pretium. Praesent neque quam, tincidunt nec leo eget, rutrum vehicula magna.\nMaecenas consequat elementum elit, id semper sem tristique et. Integer pulvinar enim quis consectetur interdum volutpat."
+				},
+				"url": {
+					"raw": "https://postman-echo.com/:action",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						":action"
+					],
+					"variable": [
+						{
+							"key": "action",
+							"value": "post"
+						}
+					]
+				},
+				"description": null
+			},
+			"response": []
+		},
+		{
+			"name": "PUT Request",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has PUT data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data sent in request'] = (responseJSON.data && responseJSON.data.length === 256);"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "PUT",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "Etiam mi lacus, cursus vitae felis et, blandit pellentesque neque. Vestibulum eget nisi a tortor commodo dignissim.\nQuisque ipsum ligula, faucibus a felis a, commodo elementum nisl. Mauris vulputate sapien et tincidunt viverra. Donec vitae velit nec metus."
+				},
+				"url": {
+					"raw": "https://postman-echo.com/put",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"put"
+					]
+				},
+				"description": "The HTTP `PUT` request method is similar to HTTP `POST`. It too is meant to \ntransfer data to a server (and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `PUT` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following \nraw HTTP request,\n\n> PUT /hi/there?hand=wave\n>\n> <request-body>\n\n\n"
+			},
+			"response": []
+		},
+		{
+			"name": "PATCH Request",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has PUT data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data sent in request'] = (responseJSON.data && responseJSON.data.length === 256);"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "PATCH",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "Curabitur auctor, elit nec pulvinar porttitor, ex augue condimentum enim, eget suscipit urna felis quis neque.\nSuspendisse sit amet luctus massa, nec venenatis mi. Suspendisse tincidunt massa at nibh efficitur fringilla. Nam quis congue mi. Etiam volutpat."
+				},
+				"url": {
+					"raw": "https://postman-echo.com/patch",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"patch"
+					]
+				},
+				"description": "The HTTP `PATCH` method is used to update resources on a server. The exact\nuse of `PATCH` requests depends on the server in question. There are a number\nof server implementations which handle `PATCH` differently. Technically, \n`PATCH` supports both Query String parameters and a Request Body.\n\nThis endpoint accepts an HTTP `PATCH` request and provides debug information\nsuch as the HTTP headers, Query String arguments, and the Request Body."
+			},
+			"response": []
+		},
+		{
+			"name": "DELETE Request",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has PUT data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data sent in request'] = (responseJSON.data && responseJSON.data.length === 256);"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "DELETE",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "application/x-www-form-urlencoded"
+					},
+					{
+						"key": "Content-Length",
+						"value": "1000",
+						"disabled": true
+					}
+				],
+				"body": {
+					"mode": "urlencoded",
+					"urlencoded": [
+						{
+							"key": "dsfs",
+							"value": "sfdds",
+							"description": "",
+							"type": "text"
+						},
+						{
+							"key": "sfdsdf",
+							"value": "sdf",
+							"description": "",
+							"type": "text"
+						}
+					]
+				},
+				"url": {
+					"raw": "https://postman-echo.com/delete",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"delete"
+					]
+				},
+				"description": "The HTTP `DELETE` method is used to delete resources on a server. The exact\nuse of `DELETE` requests depends on the server implementation. In general, \n`DELETE` requests support both, Query String parameters as well as a Request \nBody.\n\nThis endpoint accepts an HTTP `DELETE` request and provides debug information\nsuch as the HTTP headers, Query String arguments, and the Request Body."
+			},
+			"response": []
+		},
+		{
+			"name": "OPTIONS to postman echo",
+			"event": [
+				{
+					"listen": "test",
+					"script": {
+						"type": "text/javascript",
+						"exec": [
+							"var responseJSON;",
+							"",
+							"try { ",
+							"    responseJSON = JSON.parse(responseBody); ",
+							"    tests['response is valid JSON'] = true;",
+							"}",
+							"catch (e) { ",
+							"    responseJSON = {}; ",
+							"    tests['response is valid JSON'] = false;",
+							"}",
+							"",
+							"",
+							"tests['response has post data'] = _.has(responseJSON, 'data');",
+							"tests['response matches the data posted'] = (responseJSON.data && responseJSON.data.length === 256);",
+							"",
+							"tests[\"content-type equals text/plain\"] = responseJSON && responseJSON.headers && (responseJSON.headers[\"content-type\"] === 'text/plain');"
+						]
+					}
+				}
+			],
+			"request": {
+				"method": "OPTIONS",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "application/x-www-form-urlencoded"
+					}
+				],
+				"body": {},
+				"url": {
+					"raw": "https://postman-echo.com/post",
+					"protocol": "https",
+					"host": [
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"post"
+					]
+				},
+				"description": "The HTTP `POST` request method is meant to transfer data to a server \n(and elicit a response). What data is returned depends on the implementation\nof the server.\n\nA `POST` request can pass parameters to the server using \"Query String \nParameters\", as well as the Request Body. For example, in the following request,\n\n> POST /hi/there?hand=wave\n>\n> <request-body>\n\nThe parameter \"hand\" has the value \"wave\". The request body can be in multiple\nformats. These formats are defined by the MIME type of the request. The MIME \nType can be set using the ``Content-Type`` HTTP header. The most commonly used \nMIME types are:\n\n* `multipart/form-data`\n* `application/x-www-form-urlencoded`\n* `application/json`\n\nThis endpoint echoes the HTTP headers, request parameters, the contents of\nthe request body and the complete URI requested."
+			},
+			"response": []
+		},
+		{
+			"name": "HEAD request",
+			"request": {
+				"method": "HEAD",
+				"header": [
+					{
+						"key": "hello",
+						"value": "helloagain",
+						"disabled": true
+					}
+				],
+				"body": {},
+				"url": {
+					"raw": "https://www.postman-echo.com/head",
+					"protocol": "https",
+					"host": [
+						"www",
+						"postman-echo",
+						"com"
+					],
+					"path": [
+						"head"
+					]
+				},
+				"description": null
+			},
+			"response": []
+		},
+		{
+			"name": "LINK request",
+			"request": {
+				"method": "LINK",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": ""
+				},
+				"url": {
+					"raw": "https://mockbin.org/request",
+					"protocol": "https",
+					"host": [
+						"mockbin",
+						"org"
+					],
+					"path": [
+						"request"
+					]
+				},
+				"description": ""
+			},
+			"response": []
+		},
+		{
+			"name": "UNLINK request",
+			"request": {
+				"method": "UNLINK",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": ""
+				},
+				"url": {
+					"raw": "https://mockbin.org/request",
+					"protocol": "https",
+					"host": [
+						"mockbin",
+						"org"
+					],
+					"path": [
+						"request"
+					]
+				},
+				"description": ""
+			},
+			"response": []
+		},
+		{
+			"name": "LOCK request",
+			"request": {
+				"method": "LOCK",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": ""
+				},
+				"url": {
+					"raw": "https://mockbin.org/request",
+					"protocol": "https",
+					"host": [
+						"mockbin",
+						"org"
+					],
+					"path": [
+						"request"
+					]
+				},
+				"description": ""
+			},
+			"response": []
+		},
+		{
+			"name": "UNLOCK request",
+			"request": {
+				"method": "UNLOCK",
+				"header": [],
+				"body": {},
+				"url": {
+					"raw": "https://mockbin.org/request",
+					"protocol": "https",
+					"host": [
+						"mockbin",
+						"org"
+					],
+					"path": [
+						"request"
+					]
+				},
+				"description": ""
+			},
+			"response": []
+		},
+		{
+			"name": "PROFIND request",
+			"request": {
+				"method": "PROPFIND",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": ""
+				},
+				"url": {
+					"raw": "https://mockbin.org/request",
+					"protocol": "https",
+					"host": [
+						"mockbin",
+						"org"
+					],
+					"path": [
+						"request"
+					]
+				},
+				"description": ""
+			},
+			"response": []
+		},
+		{
+			"name": "VIEW request",
+			"request": {
+				"method": "VIEW",
+				"header": [
+					{
+						"key": "Content-Type",
+						"value": "text/plain"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": ""
+				},
+				"url": {
+					"raw": "https://mockbin.org/request",
+					"protocol": "https",
+					"host": [
+						"mockbin",
+						"org"
+					],
+					"path": [
+						"request"
+					]
+				},
+				"description": ""
+			},
+			"response": []
+		},
+		{
+			"name": "PURGE Request",
+			"request": {
+				"method": "PURGE",
+				"header": [],
+				"body": {},
+				"url": {
+					"raw": "https://9c76407d-5b8d-4b22-99fb-8c47a85d9848.mock.pstmn.io",
+					"protocol": "https",
+					"host": [
+						"9c76407d-5b8d-4b22-99fb-8c47a85d9848",
+						"mock",
+						"pstmn",
+						"io"
+					]
+				},
+				"description": null
+			},
+			"response": [
+				{
+					"id": "c0d81a4f-46ee-4ce4-a602-37b7d55b9983",
+					"name": "PURGE Request",
+					"originalRequest": {
+						"method": "PURGE",
+						"header": [],
+						"body": {},
+						"url": {
+							"raw": "https://9c76407d-5b8d-4b22-99fb-8c47a85d9848.mock.pstmn.io",
+							"protocol": "https",
+							"host": [
+								"9c76407d-5b8d-4b22-99fb-8c47a85d9848",
+								"mock",
+								"pstmn",
+								"io"
+							]
+						}
+					},
+					"status": "Not Found",
+					"code": 404,
+					"_postman_previewlanguage": "text",
+					"header": [
+						{
+							"key": "Access-Control-Allow-Credentials",
+							"value": "",
+							"name": "Access-Control-Allow-Credentials",
+							"description": ""
+						},
+						{
+							"key": "Access-Control-Allow-Headers",
+							"value": "",
+							"name": "Access-Control-Allow-Headers",
+							"description": ""
+						},
+						{
+							"key": "Access-Control-Allow-Methods",
+							"value": "",
+							"name": "Access-Control-Allow-Methods",
+							"description": ""
+						},
+						{
+							"key": "Access-Control-Allow-Origin",
+							"value": "*",
+							"name": "Access-Control-Allow-Origin",
+							"description": ""
+						},
+						{
+							"key": "Access-Control-Expose-Headers",
+							"value": "",
+							"name": "Access-Control-Expose-Headers",
+							"description": ""
+						},
+						{
+							"key": "Connection",
+							"value": "keep-alive",
+							"name": "Connection",
+							"description": ""
+						},
+						{
+							"key": "Content-Encoding",
+							"value": "gzip",
+							"name": "Content-Encoding",
+							"description": ""
+						},
+						{
+							"key": "Content-Length",
+							"value": "152",
+							"name": "Content-Length",
+							"description": ""
+						},
+						{
+							"key": "Content-Type",
+							"value": "application/json; charset=utf-8",
+							"name": "Content-Type",
+							"description": ""
+						},
+						{
+							"key": "Date",
+							"value": "Tue, 13 Feb 2018 13:58:56 GMT",
+							"name": "Date",
+							"description": ""
+						},
+						{
+							"key": "ETag",
+							"value": "W/\"a7-kIxN5L9H0YwilUQPUUio9A\"",
+							"name": "ETag",
+							"description": ""
+						},
+						{
+							"key": "Server",
+							"value": "nginx",
+							"name": "Server",
+							"description": ""
+						},
+						{
+							"key": "Vary",
+							"value": "Accept-Encoding",
+							"name": "Vary",
+							"description": ""
+						}
+					],
+					"cookie": [],
+					"responseTime": "375",
+					"body": "{\n    \"args\": {},\n    \"data\": \"Curabitur auctor, elit nec pulvinar porttitor, ex augue condimentum enim, eget suscipit urna felis quis neque.\\nSuspendisse sit amet luctus massa, nec venenatis mi. Suspendisse tincidunt massa at nibh efficitur fringilla. Nam quis congue mi. Etiam volutpat.\",\n    \"files\": {},\n    \"form\": {},\n    \"headers\": {\n        \"host\": \"postman-echo.com\",\n        \"content-length\": \"256\",\n        \"accept\": \"*/*\",\n        \"accept-encoding\": \"gzip, deflate\",\n        \"content-type\": \"text/plain\",\n        \"cookie\": \"sails.sid=s%3A1wOi4AdoZEbqBjGi6oSUC5Vlfje8wJvs.DHQfRLXfIBvZ%2Bv0KhLAThMDz%2FXvxh9gyxWYa0u1EZOU\",\n        \"user-agent\": \"PostmanRuntime/7.1.1\",\n        \"x-forwarded-port\": \"443\",\n        \"x-forwarded-proto\": \"https\"\n    },\n    \"json\": null,\n    \"url\": \"https://9c76407d-5b8d-4b22-99fb-8c47a85d9848.mock.pstmn.io\"\n}"
+				}
+			]
+		},
+		{
+			"name": "COPY Request",
+			"request": {
+				"method": "COPY",
+				"header": [],
+				"body": {},
+				"url": {
+					"raw": "https://mockbin.org/request",
+					"protocol": "https",
+					"host": [
+						"mockbin",
+						"org"
+					],
+					"path": [
+						"request"
+					]
+				},
+				"description": null
+			},
+			"response": [
+				{
+					"id": "6367d22f-0cf7-48f2-a41d-5b9ed11cbff5",
+					"name": "COPY Request",
+					"originalRequest": {
+						"method": "COPY",
+						"header": [],
+						"body": {},
+						"url": {
+							"raw": "https://mockbin.org/request",
+							"protocol": "https",
+							"host": [
+								"mockbin",
+								"org"
+							],
+							"path": [
+								"request"
+							]
+						}
+					},
+					"status": "OK",
+					"code": 200,
+					"_postman_previewlanguage": "json",
+					"header": [
+						{
+							"key": "Access-Control-Allow-Credentials",
+							"value": "true",
+							"name": "Access-Control-Allow-Credentials",
+							"description": "Indicates whether or not the response to the request can be exposed when the credentials flag is true. When used as part of a response to a preflight request, this indicates whether or not the actual request can be made using credentials."
+						},
+						{
+							"key": "Access-Control-Allow-Headers",
+							"value": "host,connection,accept-encoding,x-forwarded-for,cf-ray,x-forwarded-proto,cf-visitor,cache-control,postman-token,user-agent,accept,cookie,cf-connecting-ip,x-request-id,x-forwarded-port,via,connect-time,x-request-start,total-route-time,content-length",
+							"name": "Access-Control-Allow-Headers",
+							"description": "Used in response to a preflight request to indicate which HTTP headers can be used when making the actual request."
+						},
+						{
+							"key": "Access-Control-Allow-Methods",
+							"value": "COPY",
+							"name": "Access-Control-Allow-Methods",
+							"description": "Specifies the method or methods allowed when accessing the resource. This is used in response to a preflight request."
+						},
+						{
+							"key": "Access-Control-Allow-Origin",
+							"value": "*",
+							"name": "Access-Control-Allow-Origin",
+							"description": "Specifies a URI that may access the resource. For requests without credentials, the server may specify '*' as a wildcard, thereby allowing any origin to access the resource."
+						},
+						{
+							"key": "CF-RAY",
+							"value": "3fb595d5facaa302-HKG",
+							"name": "CF-RAY",
+							"description": "Custom header"
+						},
+						{
+							"key": "Connection",
+							"value": "keep-alive",
+							"name": "Connection",
+							"description": "Options that are desired for the connection"
+						},
+						{
+							"key": "Content-Encoding",
+							"value": "gzip",
+							"name": "Content-Encoding",
+							"description": "The type of encoding used on the data."
+						},
+						{
+							"key": "Content-Type",
+							"value": "application/json; charset=utf-8",
+							"name": "Content-Type",
+							"description": "The mime type of this content"
+						},
+						{
+							"key": "Date",
+							"value": "Wed, 14 Mar 2018 09:06:37 GMT",
+							"name": "Date",
+							"description": "The date and time that the message was sent"
+						},
+						{
+							"key": "Etag",
+							"value": "W/\"4ac-YP9NIoQ5TiGJRPuQSZMKtA\"",
+							"name": "Etag",
+							"description": "An identifier for a specific version of a resource, often a message digest"
+						},
+						{
+							"key": "Expect-CT",
+							"value": "max-age=604800, report-uri=\"https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct\"",
+							"name": "Expect-CT",
+							"description": "Custom header"
+						},
+						{
+							"key": "Server",
+							"value": "cloudflare",
+							"name": "Server",
+							"description": "A name for the server"
+						},
+						{
+							"key": "Transfer-Encoding",
+							"value": "chunked",
+							"name": "Transfer-Encoding",
+							"description": "The form of encoding used to safely transfer the entity to the user. Currently defined methods are: chunked, compress, deflate, gzip, identity."
+						},
+						{
+							"key": "Vary",
+							"value": "Accept, Accept-Encoding",
+							"name": "Vary",
+							"description": "Tells downstream proxies how to match future request headers to decide whether the cached response can be used rather than requesting a fresh one from the origin server."
+						},
+						{
+							"key": "Via",
+							"value": "1.1 vegur",
+							"name": "Via",
+							"description": "Informs the client of proxies through which the response was sent."
+						},
+						{
+							"key": "X-Powered-By",
+							"value": "mockbin",
+							"name": "X-Powered-By",
+							"description": "Specifies the technology (ASP.NET, PHP, JBoss, e.g.) supporting the web application (version details are often in X-Runtime, X-Version, or X-AspNet-Version)"
+						}
+					],
+					"cookie": [
+						{
+							"expires": "Thu Mar 14 2019 13:12:10 GMT+0530 (IST)",
+							"httpOnly": true,
+							"domain": "mockbin.org",
+							"path": "/",
+							"secure": false,
+							"value": "dfb94a3e1f3f8a9956138e4896847caf21521013330",
+							"key": "__cfduid"
+						}
+					],
+					"body": "{\n  \"startedDateTime\": \"2018-03-14T09:06:37.443Z\",\n  \"clientIPAddress\": \"106.51.70.154\",\n  \"method\": \"COPY\",\n  \"url\": \"https://mockbin.org/request\",\n  \"httpVersion\": \"HTTP/1.1\",\n  \"cookies\": {\n    \"__cfduid\": \"dfb94a3e1f3f8a9956138e4896847caf21521013330\"\n  },\n  \"headers\": {\n    \"host\": \"mockbin.org\",\n    \"connection\": \"close\",\n    \"accept-encoding\": \"gzip\",\n    \"x-forwarded-for\": \"106.51.70.154, 172.68.255.127\",\n    \"cf-ray\": \"3fb595d5facaa302-HKG\",\n    \"x-forwarded-proto\": \"http\",\n    \"cf-visitor\": \"{\\\"scheme\\\":\\\"https\\\"}\",\n    \"cache-control\": \"no-cache\",\n    \"postman-token\": \"8d5b9832-75df-432f-90a3-284dacef0478\",\n    \"user-agent\": \"PostmanRuntime/7.1.1\",\n    \"accept\": \"*/*\",\n    \"cookie\": \"__cfduid=dfb94a3e1f3f8a9956138e4896847caf21521013330\",\n    \"cf-connecting-ip\": \"106.51.70.154\",\n    \"x-request-id\": \"0e41473d-5130-4a6e-968d-b2a16cda3364\",\n    \"x-forwarded-port\": \"80\",\n    \"via\": \"1.1 vegur\",\n    \"connect-time\": \"2\",\n    \"x-request-start\": \"1521018397437\",\n    \"total-route-time\": \"0\",\n    \"content-length\": \"0\"\n  },\n  \"queryString\": {},\n  \"postData\": {\n    \"mimeType\": \"application/octet-stream\",\n    \"text\": \"\",\n    \"params\": []\n  },\n  \"headersSize\": 637,\n  \"bodySize\": 0\n}"
+				}
+			]
+		}
+	]
+}
\ No newline at end of file
diff --git a/codegens/shell-httpie/scripts/test-lint.sh b/codegens/shell-httpie/scripts/test-lint.sh
new file mode 100755
index 0000000..b6879c1
--- /dev/null
+++ b/codegens/shell-httpie/scripts/test-lint.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# ----------------------------------------------------------------------------------------------------------------------
+# This script is intended to contain all actions pertaining to code style checking, linting and normalisation.
+#
+# 1. The script executes linting routines on specific folders.
+# ----------------------------------------------------------------------------------------------------------------------
+
+# Stop on first error
+set -e;
+
+# banner
+echo -e "\033[93mLinting and style-checking...\033[0m";
+echo -en "\033[0m\033[2m";
+echo -e "eslint `eslint -v`\033[0m\n";
+
+# run style checker
+eslint ./lib/** ./test/** ;
+echo -en "\033[92mNo lint errors found.\n\033[0m";
diff --git a/codegens/shell-httpie/scripts/test-unit.sh b/codegens/shell-httpie/scripts/test-unit.sh
new file mode 100755
index 0000000..52287a2
--- /dev/null
+++ b/codegens/shell-httpie/scripts/test-unit.sh
@@ -0,0 +1,43 @@
+#!/bin/bash
+# ----------------------------------------------------------------------------------------------------------------------
+# This script is intended to execute all app and repository unit and integration tests.
+# ----------------------------------------------------------------------------------------------------------------------
+
+# stop on first error
+set -e;
+
+# function to be called on exit
+# and ensure cleanup is called before the script exits
+function cleanup {
+  unset XUNIT_FILE;
+
+  if [ "$?" != "0" ]; then
+    exit 1;
+  fi
+}
+trap cleanup EXIT;
+
+# set file for xunit report
+export XUNIT_FILE=".tmp/report.xml";
+
+# run mocha tests
+echo -e "\033[93mRunning mocha unit tests...\033[0m";
+echo -en "\033[0m\033[2mmocha `mocha --version`\033[0m";
+
+# set mocha reporter
+if [ "$SHIPPABLE" = "true" ]; then
+  MOCHA_REPORTER="xunit";
+  ISTANBUL_REPORT="--report cobertura";
+else
+  MOCHA_REPORTER="spec";
+  ISTANBUL_REPORT="";
+fi
+
+# delete old repor directory
+[ -d .coverage ] && rm -rf .coverage && mkdir .coverage;
+
+# run test
+node --max-old-space-size=2048 ../../node_modules/.bin/istanbul cover ${ISTANBUL_REPORT} \
+  --dir ./.coverage --print both _mocha -- \
+  --timeout 5000 --reporter ${MOCHA_REPORTER} --reporter-options output=${XUNIT_FILE} \
+  test/unit/*.test.js --recursive --prof --grep "$1";
diff --git a/codegens/shell-httpie/scripts/test.sh b/codegens/shell-httpie/scripts/test.sh
new file mode 100755
index 0000000..9e0436b
--- /dev/null
+++ b/codegens/shell-httpie/scripts/test.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+# ----------------------------------------------------------------------------------------------------------------------
+# This script is intended to be executed as all-inclusive test and artefact creation (excluding packaging and release.)
+# As such, a clean exit from this script implies all tests have passed and the code will not fail a build. (However,
+# build may still fail due to errors on build executing servers and as such has no relation with code quality.)
+#
+# This script executes all non time-bound tests, excluding browser tests and performance tests.
+# ----------------------------------------------------------------------------------------------------------------------
+
+# Stop on first error
+set -e;
+
+# information block
+
+# TODO - Add ASCII art banner for Cloud API
+
+echo -e "\033[0m\033[2m";
+date;
+echo "node `node -v`";
+echo "npm  v`npm -v`";
+which git &>/dev/null && git --version;
+echo -e "\033[0m";
+
+# git version
+which git &>/dev/null && \
+  echo -e "Running on branch: \033[4m`git rev-parse --abbrev-ref HEAD`\033[0m (${NODE_ENV:=development} environment)";
+
+# run lint
+npm run test-lint;
+
+# run unit tests
+npm run test-unit;
diff --git a/codegens/shell-httpie/test/unit/converter.test.js b/codegens/shell-httpie/test/unit/converter.test.js
new file mode 100644
index 0000000..a51e548
--- /dev/null
+++ b/codegens/shell-httpie/test/unit/converter.test.js
@@ -0,0 +1,156 @@
+var expect = require('chai').expect,
+  sdk = require('postman-collection'),
+  exec = require('shelljs').exec,
+  newman = require('newman'),
+  parallel = require('async').parallel,
+  convert = require('../../index').convert,
+  sanitize = require('../../lib/util/sanitize').quote,
+  mainCollection = require('../../examples/test-collection.json');
+
+
+/**
+ * runs codesnippet then compare it with newman output
+ *
+ * @param {String} codeSnippet - code snippet that needed to run using java
+ * @param {Object} collection - collection which will be run using newman
+ * @param {Function} done - callback for async calls
+ */
+function runSnippet (codeSnippet, collection, done) {
+  //  step by step process for compile, run code snippet, then comparing its output with newman
+  parallel([
+    function (callback) {
+
+      // This is added for shelljs module i.e. it hangs if printf is not provided.
+      codeSnippet = 'printf \'\' | ' + codeSnippet;
+      return exec(codeSnippet, function (err, stdout, stderr) {
+        if (err) {
+          return callback(err);
+        }
+        if (stderr) {
+          return callback(stderr);
+        }
+        try {
+          stdout = JSON.parse(stdout);
+        }
+        catch (e) {
+          console.error(e);
+        }
+        return callback(null, stdout);
+      });
+    },
+    function (callback) {
+      newman.run({
+        collection: collection
+      }).on('request', function (err, summary) {
+        if (err) {
+          return callback(err);
+        }
+
+        var stdout = summary.response.stream.toString();
+        // }
+        try {
+          stdout = JSON.parse(stdout);
+        }
+        catch (e) {
+          console.error(e);
+        }
+        return callback(null, stdout);
+      });
+    }
+  ], function (err, result) {
+    if (err) {
+      expect.fail(null, null, err);
+    }
+    else if (typeof result[1] !== 'object' || typeof result[0] !== 'object') {
+      expect(result[0].trim()).to.include(result[1].trim());
+    }
+    else {
+      const propertiesTodelete = ['cookies', 'headersSize', 'startedDateTime', 'clientIPAddress'],
+        headersTodelete = [
+          'accept-encoding',
+          'user-agent',
+          'cf-ray',
+          'x-request-id',
+          'x-request-start',
+          'connect-time',
+          'x-forwarded-for',
+          'x-forwarded-port',
+          'content-type',
+          'content-length',
+          'accept',
+          'total-route-time',
+          'cookie',
+          'kong-cloud-request-id',
+          'x-real-ip',
+          'cache-control',
+          'postman-token'
+        ];
+      if (result[0]) {
+        propertiesTodelete.forEach(function (property) {
+          delete result[0][property];
+        });
+        if (result[0].headers) {
+          headersTodelete.forEach(function (property) {
+            delete result[0].headers[property];
+          });
+        }
+      }
+      if (result[1]) {
+        propertiesTodelete.forEach(function (property) {
+          delete result[1][property];
+        });
+        if (result[1].headers) {
+          headersTodelete.forEach(function (property) {
+            delete result[1].headers[property];
+          });
+        }
+      }
+      expect(result[0]).deep.equal(result[1]);
+    }
+    return done();
+  });
+}
+
+describe('Shell-Httpie convert function', function () {
+  describe.skip('convert for different request types', function () {
+
+    mainCollection.item.forEach(function (item) {
+      if (item.request.body.mode !== 'formdata') {
+        it(item.name, function (done) {
+          var request = new sdk.Request(item.request),
+            collection = {
+              item: [
+                {
+                  request: request.toJSON()
+                }
+              ]
+            },
+            options = {
+              indentCount: 3,
+              indentType: 'space',
+              multiLine: true,
+              followRedirect: true,
+              longFormat: true
+            };
+
+          convert(request, options, function (error, snippet) {
+            if (error) {
+              expect.fail(null, null, error);
+              return;
+            }
+            runSnippet(snippet, collection, done);
+          });
+        });
+      }
+    });
+  });
+});
+
+describe('Sanitize function', function () {
+  it('should return empty string when input is not a string type', function () {
+    expect(sanitize(123)).to.equal('');
+    expect(sanitize(null)).to.equal('');
+    expect(sanitize({})).to.equal('');
+    expect(sanitize([])).to.equal('');
+  });
+});