serverless-http-invoker 1.0.9

package/.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at serverless-http-invoker@willeke.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

package/.github/CONTRIBUTING.md

@@ -0,0 +1,16 @@
+# Contributing
+
+:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
+
+The following is a set of guidelines for contributing to this project. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
+
+## How Can I Contribute?
+
+Feel free to check [issues page](https://github.com/activescott/serverless-http-invoker/issues) to find an enhancement to implement or bug to fix. You could also **[Improve the documentation](https://github.com/activescott/serverless-http-invoker/edit/main/README.md)**, **Report a Bug**, or **Suggest an Enhancement**.
+
+### Contribute Code
+
+- Fork this repository and [submit a pull request](https://help.github.com/articles/creating-a-pull-request/).
+- Write tests
+- Ensure the linter passes with `npm run lint`
+- Ensure the tests pass at [the CI Server](https://travis-ci.org/activescott/serverless-http-invoker) by [following the status](https://help.github.com/articles/about-statuses/) of your pull request.

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,32 @@
+## What did you implement:
+
+Closes #XXXXX
+
+<!--
+Briefly describe the feature if no issue exists for this PR
+-->
+
+## How did you implement it:
+
+<!--
+If this is a nontrivial change please briefly describe your implementation so its easy for us to understand and review your code.
+-->
+
+## How can we verify it:
+
+<!--
+Add any applicable config, commands, screenshots or other resources
+to make it easy for us to verify this works. The easier you make it for us
+to review a PR, the faster we can review and merge it.
+
+Examples:
+* serverless.yml - Fully functioning to easily deploy changes
+* Screenshots - Showing the difference between your output and the master
+* Other - Anything else that comes to mind to help us evaluate
+-->
+
+## Todos:
+
+- [ ] Write tests
+- [ ] Fix linting errors
+- [ ] All tests pass on our CI Server: https://travis-ci.org/activescott/serverless-http-invoker

package/.github/dependabot.yml

@@ -0,0 +1,17 @@
+version: 2
+updates:
+  # docs v2 https://docs.github.com/en/free-pro-team@latest/github/administering-a-repository/configuration-options-for-dependency-updates
+  - package-ecosystem: "npm"
+    schedule:
+      interval: "monthly"
+      # Check for npm updates on Sundays
+      day: "saturday"
+    allow:
+      - dependency-type: "production"
+    directory: "/"
+    commit-message:
+      # for production deps, prefix commit messages with "fix" (trigger a patch release)
+      prefix: "fix"
+      # for development deps, prefix commit messages with "chore" (do NOT trigger an npm release)
+      prefix-development: "chore"
+      include: "scope"

package/.github/issue_template.md

@@ -0,0 +1,9 @@
+### Expected behavior:
+
+### Actual behavior:
+
+### Steps to reproduce the problem:
+
+### Environment:
+
+Please include version of serverless-http-invoker, version of serverless, version of node, and operating system name and version

package/.github/workflows/build.yml

@@ -0,0 +1,89 @@
+name: build
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: actions/checkout@v1
+      - name: "Use Node.js (deliberately not using matrix)"
+        uses: actions/setup-node@v1
+        with:
+          node-version: v12.x
+
+      - name: install dependencies
+        run: |
+          npm i
+
+      - name: lint
+        run: |
+          npm run lint
+
+  build_and_test:
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        node: [10, 12, 14]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+
+      - name: install dependencies
+        run: |
+          npm i
+
+      - name: test
+        env:
+          CI_NODE_VERSION: ${{ matrix.node }}
+        run: |
+          npm run test
+
+      - name: publish coverage
+        uses: coverallsapp/github-action@master
+        continue-on-error: true
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          flag-name: nodejs-${{ matrix.node }}
+          parallel: true
+
+  finish_tests:
+    needs: build_and_test
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Coveralls Finished
+        uses: coverallsapp/github-action@master
+        continue-on-error: true
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          parallel-finished: true
+
+  deploy_package:
+    needs: finish_tests
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v1
+
+      - name: Use Node.js v12.x
+        uses: actions/setup-node@v1
+        with:
+          node-version: v12.x
+
+      #- name: debug deploy_package
+      #  uses: actions/bin/debug@master
+
+      - name: deploy via semantic-release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          npx semantic-release@17

package/.github/workflows/dependabot-validate.yml

@@ -0,0 +1,19 @@
+name: dependabot validate
+
+on:
+  pull_request:
+    paths:
+      - ".github/dependabot.yml"
+      - ".github/workflows/dependabot-validate.yml"
+jobs:
+  validate:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: marocchino/validate-dependabot@v1
+        id: validate
+      - uses: marocchino/sticky-pull-request-comment@v2
+        if: always()
+        with:
+          header: validate-dependabot
+          message: ${{ steps.validate.outputs.markdown }}

package/.nycrc.yaml

@@ -0,0 +1,14 @@
+reporter:
+  - lcov
+  - html
+check-coverage: true
+branches: 90
+lines: 90
+functions: 90
+statements: 90
+all: true
+exclude:
+  - scripts/
+  - test/
+  - coverage/
+  - release.config.js

package/.prettierignore

@@ -0,0 +1,4 @@
+.nyc_output/
+coverage/
+dist/
+docs/todo.md

package/.prettierrc

@@ -0,0 +1 @@
+semi: false

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 scott willeke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+[![npm version](https://badge.fury.io/js/serverless-http-invoker.svg)](https://www.npmjs.com/package/serverless-http-invoker)
+[![npm downloads](https://img.shields.io/npm/dt/serverless-http-invoker.svg?logo=npm)](https://www.npmjs.com/package/serverless-http-invoker)
+[![Build Status](https://github.com/activescott/serverless-http-invoker/workflows/build/badge.svg)](https://github.com/activescott/serverless-http-invoker/actions)
+[![Coverage Status](https://coveralls.io/repos/github/activescott/serverless-http-invoker/badge.svg)](https://coveralls.io/github/activescott/serverless-http-invoker)
+[![License](https://img.shields.io/github/license/activescott/serverless-http-invoker.svg)](https://github.com/activescott/serverless-http-invoker/blob/main/LICENSE)
+[![GitHub stars](https://img.shields.io/github/stars/activescott/serverless-http-invoker.svg?style=social)](https://github.com/activescott/serverless-http-invoker)
+
+# serverless-http-invoker
+
+Locally invoke [Serverless](https://github.com/serverless/serverless) functions via their HTTP event as specified in Serverless.yml.
+
+It makes it easy to test not only your handler logic, but also ensures that you have your http events setup properly in serverless.yml without deploying.
+
+<!-- TOC -->
+
+- [Usage / Quick Start](#usage--quick-start)
+- [Prerequisites / Usage Requirements](#prerequisites--usage-requirements)
+- [Install](#install)
+- [Features](#features)
+- [Contributing 🤝](#contributing-🤝)
+- [Show your support](#show-your-support)
+- [Release Process (Deploying to NPM)](#release-process-deploying-to-npm)
+- [License 📝](#license-📝)
+
+<!-- /TOC -->
+
+## Usage / Quick Start
+
+Use it in tests of Serverless functions to test your HTTP endpoints along with the handler code. For example, you can write the following to test a Serverless function:
+
+    it('should invoke simple path', function () {
+      let response = invoker.invoke('GET api/hello')
+      return expect(response).to.eventually.have.property('statusCode', 200)
+    })
+
+The test above is a test of a Serverless function defined in a `Serverless.yml` as follows:
+
+    functions:
+      hello:
+        handler: handler.hello
+        events:
+          - http:
+              path: api/hello
+              method: get
+
+Some of the more common use cases are demonstrated in the basic tests at [the basic test cases](examples/basic/basic.spec.js).
+An exhaustive list of what is supported in Some of the more common use cases are demonstrated in the basic tests at [the comprehensive test cases](examples/comprehensive/comprehensive.spec.js).
+
+## Prerequisites / Usage Requirements
+
+Requires Node.js latest, LTS, and v10 ([tested](https://travis-ci.org/activescott/serverless-http-invoker)).
+
+If you need Node.js v6.x - v9.x support you can use [serverless-http-invoker@0.8.6](https://www.npmjs.com/package/serverless-http-invoker/v/0.8.6).
+
+Requires Serverless Framework v1.x.
+If you are new to the Serverless Framework, check out the [Serverless Framework Getting Started Guide](https://serverless.com/framework/docs/getting-started/).
+
+## Install
+
+npm (`npm install serverless-http-invoker --save-dev`) or yarn (`yarn add serverless-http-invoker --dev`)
+
+## Features
+
+- Simple to reference your handler
+- Tests the serverless route is configured in serverless.yml as well as your handler code
+- Test Framework agnostic (mocha, jest, etc.)
+
+## Contributing 🤝
+
+This is a community project. We invite your participation through issues and pull requests! You can peruse the [contributing guidelines](.github/CONTRIBUTING.md).
+
+## Show your support
+
+Give a ⭐️ if this project helped you!
+
+## Release Process (Deploying to NPM)
+
+We use [semantic-release](https://github.com/semantic-release/semantic-release) to consistently release [semver](https://semver.org/)-compatible versions. This project deploys to multiple [npm distribution tags](https://docs.npmjs.com/cli/dist-tag). Each of the below branches correspond to the following npm distribution tags:
+
+| branch | npm distribution tag |
+| ------ | -------------------- |
+| main   | latest               |
+| beta   | beta                 |
+
+To trigger a release use a Conventional Commit following [Angular Commit Message Conventions](https://github.com/angular/angular.js/blob/master/DEVELOPERS.md#-git-commit-guidelines) on one of the above branches.
+
+## License 📝
+
+Copyright © 2017 [Scott Willeke](https://github.com/activescott).
+
+This project is [MIT](https://github.com/activescott/serverless-http-invoker/blob/main/LICENSE) licensed.

package/examples/basic/basic.spec.js

@@ -0,0 +1,41 @@
+"use strict"
+require("../../test/support/setup")
+const path = require("path")
+const expect = require("chai").expect
+const ServerlessInvoker = require("../../index")
+
+describe("basic", function() {
+  let sls = null
+  beforeEach(function() {
+    sls = new ServerlessInvoker(path.join(__dirname))
+  })
+
+  it("should invoke simple path", function() {
+    const response = sls.invoke("GET api/hello")
+    return expect(response).to.eventually.have.property("statusCode", 200)
+  })
+
+  it("should have event.httpMethod", function() {
+    const response = sls.invoke("GET api/hello")
+    return expect(response).to.eventually.have.deep.nested.property(
+      "body.input.httpMethod",
+      "GET"
+    )
+  })
+
+  it("should have event.path", function() {
+    const response = sls.invoke("GET api/hello")
+    return expect(response).to.eventually.have.deep.nested.property(
+      "body.input.path",
+      "/api/hello"
+    )
+  })
+
+  it("should have event.resource", function() {
+    const response = sls.invoke("GET api/hello")
+    return expect(response).to.eventually.have.deep.nested.property(
+      "body.input.resource",
+      "/api/hello"
+    )
+  })
+})

package/examples/basic/handler.js

@@ -0,0 +1,19 @@
+"use strict"
+const assert = require("assert")
+
+module.exports.hello = async event => {
+  return {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(
+      {
+        message: "Go Serverless v1.0! Your function executed successfully!",
+        input: event
+      },
+      null,
+      2
+    )
+  }
+}

package/examples/basic/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "basic",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "serverless": "^1.46.1"
+  }
+}

package/examples/basic/serverless.yml

@@ -0,0 +1,14 @@
+service: basic-example
+
+provider:
+  name: aws
+  runtime: nodejs10.x
+  region: us-west-2
+
+functions:
+  hello:
+    handler: handler.hello
+    events:
+      - http:
+          path: api/hello
+          method: get

package/examples/comprehensive/comprehensive.spec.js

@@ -0,0 +1,170 @@
+"use strict"
+require("../../test/support/setup")
+const path = require("path")
+const expect = require("chai").expect
+const ServerlessInvoker = require("../../index")
+
+let sls = null
+
+beforeEach(function() {
+  process.chdir(path.join(__dirname))
+  sls = new ServerlessInvoker(path.join(__dirname))
+})
+
+it("should work with callbacks too", function() {
+  const response = sls.invoke("GET api/callback")
+  return expect(response).to.eventually.have.property("statusCode", 200)
+})
+
+it("should invoke path with params", function() {
+  const response = sls.invoke("GET api/hello/world")
+  return expect(response).to.eventually.have.property("statusCode", 200)
+})
+
+it("should invoke path with shorthand", function() {
+  const response = sls.invoke("GET api/shorthand")
+  return expect(response).to.eventually.have.property("statusCode", 200)
+})
+
+it("should invoke path with multiple params", function() {
+  const response = sls.invoke("GET api/res1/1111/res2/2222")
+  return expect(response).to.eventually.have.property("statusCode", 200)
+})
+
+it("should parse json response body", function() {
+  const response = sls.invoke("GET api/hello")
+  expect(response).to.eventually.have.property("statusCode", 200)
+  return expect(response).to.eventually.have.deep.nested.property(
+    "body.message",
+    "Go Serverless v1.0! Your function executed successfully!"
+  )
+})
+
+it("should load environment", function() {
+  const response = sls.invoke("GET api/env")
+  expect(response).to.eventually.have.property("statusCode", 200)
+  return expect(response).to.eventually.have.deep.nested.property(
+    "body.message",
+    "process.env.MY_SIMPLE==simple value"
+  )
+})
+
+it("should pass data to POST", function() {
+  const response = sls.invoke("POST api/postit", { body: "boo" })
+  return expect(response).to.eventually.have.deep.property("body", {
+    message: "postit:boo"
+  })
+})
+
+it("should pass pathParameters with values when present", function() {
+  const response = sls.invoke("GET api/res1/xxx/res2/yyy")
+  return response.then(resp => {
+    return expect(resp.body.input).to.have.deep.property("pathParameters", {
+      res1ID: "xxx",
+      res2ID: "yyy"
+    })
+  })
+})
+
+it("should pass pathParameters along with existing event too", function() {
+  const response = sls.invoke("GET api/res1/xxx/res2/yyy", {
+    requestPayload: "boo"
+  })
+  return response.then(resp => {
+    expect(resp.body).to.have.property("input")
+    expect(resp.body.input).to.have.deep.property("pathParameters", {
+      res1ID: "xxx",
+      res2ID: "yyy"
+    })
+    expect(resp.body.input).to.have.property("requestPayload", "boo")
+  })
+})
+
+it("should pass pathParameters empty when not present", function() {
+  const response = sls.invoke("GET api/hello")
+  return response.then(resp => {
+    return expect(resp.body.input).to.have.deep.property("pathParameters", {})
+  })
+})
+
+it("should pass greedy path params", function() {
+  const response = sls.invoke("GET api/greedy/blah/blah/blah")
+  return response.then(resp => {
+    return expect(resp.body.input).to.have.deep.property("pathParameters", {
+      money: "blah/blah/blah"
+    })
+  })
+})
+
+it("should pass queryStringParameters with values when present", function() {
+  const response = sls.invoke("GET api/with_querystring_params?p1=val1&p2=val2")
+  return response.then(resp => {
+    return expect(resp.body.input).to.have.deep.property(
+      "queryStringParameters",
+      {
+        p1: "val1",
+        p2: "val2"
+      }
+    )
+  })
+})
+
+it("should pass queryStringParameters even when not present", function() {
+  const response = sls.invoke("GET api/with_querystring_params")
+  return response.then(resp => {
+    return expect(resp.body.input).to.have.deep.property(
+      "queryStringParameters",
+      {}
+    )
+  })
+})
+
+it("should match urls with query strings and path params in url", function() {
+  const response = sls.invoke(
+    "GET api/with_querystring_params_and_pathparams/ppvalue?qs1=qsval1"
+  )
+  return response.then(resp => {
+    expect(resp.body.input).to.have.deep.property("queryStringParameters", {
+      qs1: "qsval1"
+    })
+    return expect(resp.body.input).to.have.deep.property("pathParameters", {
+      pathparam1: "ppvalue"
+    })
+  })
+})
+
+it("should marshal raw lambda exceptions back as http responses", function() {
+  const response = sls.invoke("GET api/throwWorld")
+  return expect(response).to.eventually.have.property("statusCode", 502)
+})
+
+it("should marshal raw handled lambda errors back as http responses", function() {
+  const response = sls.invoke("GET api/errorWorld")
+  return expect(response).to.eventually.have.property("statusCode", 502)
+})
+
+it("should error if path isn't found", function() {
+  const response = sls.invoke("GET api/DOES_NOT_EXIST")
+  return expect(response).to.eventually.be.rejectedWith(
+    /^Serverless http event not found for HTTP request/
+  )
+})
+
+it("should try to find service path in same dir", function() {
+  process.chdir(path.join(__dirname))
+  const localSls = new ServerlessInvoker()
+  expect(localSls.servicePath).to.match(/examples\/comprehensive$/)
+})
+
+it("should try to find service path in parent dir", function() {
+  process.chdir(path.join(__dirname, "./subdir"))
+  const localSls = new ServerlessInvoker()
+  expect(localSls.servicePath).to.match(/examples\/comprehensive$/)
+})
+
+it("should fail if serverless.yml not found", function() {
+  process.chdir(path.join(__dirname, "../../test-data/no-serverless-found"))
+  expect(() => new ServerlessInvoker()).to.throw(
+    /^Cannot find serverless.yml. Started search in working directory/
+  )
+})

package/examples/comprehensive/handler.js

@@ -0,0 +1,86 @@
+"use strict"
+const assert = require("assert")
+
+module.exports.hello = async event => {
+  return {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(
+      {
+        message: "Go Serverless v1.0! Your function executed successfully!",
+        input: event
+      },
+      null,
+      2
+    )
+  }
+}
+
+module.exports.callback = (event, context, callback) => {
+  const response = {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(
+      {
+        message: "Go Serverless v1.00! Your function executed successfully!",
+        input: event
+      },
+      null,
+      2
+    )
+  }
+  callback(null, response)
+}
+
+module.exports.throwWorld = async () => {
+  throw new Error("throw world")
+}
+
+module.exports.errorWorld = (event, context, callback) => {
+  callback(new Error("throw world"), null)
+}
+
+module.exports.with_querystring_params = async event => {
+  return {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      message: "QueryStringParams on prop",
+      queryStringParameters: event.queryStringParameters,
+      input: event
+    })
+  }
+}
+
+module.exports.env = async event => {
+  assert(process.env.MY_SIMPLE === "simple value")
+
+  return {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      message: "process.env.MY_SIMPLE==" + process.env.MY_SIMPLE,
+      input: event
+    })
+  }
+}
+
+module.exports.postit = async event => {
+  return {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      message: "postit:" + event.body
+    })
+  }
+}

package/examples/comprehensive/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "comprehensive",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "serverless": "^1.46.1"
+  }
+}

package/examples/comprehensive/serverless.yml

@@ -0,0 +1,95 @@
+service: basic-example # NOTE: update this with your service name
+
+provider:
+  name: aws
+  runtime: nodejs10.x
+  region: us-west-2
+
+  environment:
+    MY_SIMPLE: "simple value"
+    MY_DYNAMIC: "${self:provider.stage}"
+
+functions:
+  hello:
+    handler: handler.hello
+    events:
+      - http:
+          path: api/hello
+          method: get
+
+  with_params:
+    handler: handler.hello
+    events:
+      - http:
+          path: api/hello/{greeting}
+          method: get
+
+  with_greedy_path_params:
+    handler: handler.hello
+    events:
+      - http:
+          path: api/greedy/{money+}
+          method: get
+
+  shorthand_path_syntax:
+    handler: handler.hello
+    events:
+      - http: GET api/shorthand
+
+  malformed_http_event:
+    handler: handler.hello
+    events:
+      - http:
+        path: note_how_path_isnt_indented_enough
+        method: get
+
+  path_with_multiple_params:
+    handler: handler.hello
+    events:
+      - http: GET api/res1/{res1ID}/res2/{res2ID}
+
+  env:
+    handler: handler.env
+    events:
+      - http:
+          path: api/env
+          method: get
+
+  postit:
+    handler: handler.postit
+    events:
+      - http:
+          path: api/postit
+          method: POST
+
+  with_querystring_params:
+    handler: handler.with_querystring_params
+    events:
+      - http:
+          path: api/with_querystring_params
+          method: get
+
+  with_querystring_params_and_pathparams:
+    handler: handler.with_querystring_params
+    events:
+      - http:
+          path: api/with_querystring_params_and_pathparams/{pathparam1}
+          method: get
+  throwWorld:
+    handler: handler.throwWorld
+    events:
+      - http:
+          path: api/throwWorld
+          method: get
+  errorWorld:
+    handler: handler.errorWorld
+    events:
+      - http:
+          path: api/errorWorld
+          method: get
+  callback:
+    handler: handler.callback
+    events:
+      - http:
+          path: api/callback
+          method: get

package/examples/comprehensive/subdir/.keep

@@ -0,0 +1 @@
+just to keep this directory here for a test.

package/index.js

@@ -0,0 +1,289 @@
+"use strict"
+const path = require("path")
+const fs = require("fs")
+const Serverless = require("serverless")
+const Promise = require("bluebird")
+const { wrap } = require("lambda-wrapper")
+const assert = require("assert")
+const url = require("url")
+const querystring = require("querystring")
+
+class ServerlessInvoker {
+  /**
+   * Initializes an instance of the class.
+   * @param {*string} servicePath Path to the directory containing the serverless file.
+   */
+  constructor(servicePath) {
+    this.servicePath = servicePath || this.findServicePath()
+    this.serverless = null
+    this.serverlessEvents = null
+  }
+
+  findServicePath() {
+    let dir = process.cwd()
+    while (dir !== "/" && !fs.existsSync(path.join(dir, "serverless.yml"))) {
+      dir = path.dirname(dir)
+    }
+    if (dir === "/") {
+      throw new Error(
+        `Cannot find serverless.yml. Started search in working directory ${process.cwd()}`
+      )
+    }
+    return dir
+  }
+
+  initializeServerless() {
+    const config = {
+      servicePath: this.servicePath
+    }
+    const sls = new Serverless(config)
+    // NOTE: I've seen sls.init() run very slowly; nearly 500ms!
+    return sls.init().then(() => {
+      return sls.variables.populateService().then(() => {
+        sls.service.setFunctionNames({})
+        sls.service.mergeArrays()
+        sls.service.validate()
+        this.serverless = sls
+      })
+    })
+  }
+
+  /**
+   * Invokes the serverless function bound to the HTTP event with the provided specification.
+   * @param {*string} httpRequest A method+path like 'GET api/users/me'.
+   * @param {*object} event The event that should be submitted to the http endpoint.
+   * @param {*object} context The context passed to the lambda function
+   */
+  invoke(httpRequest, event, context) {
+    // Read the serverless.yml file
+    return this.initializeServerless()
+      .then(() => this.loadServerlessEvents())
+      .then(httpEvents => {
+        // find the event that matches the specified httpRequest
+        let httpEvent = httpEvents.find(e => e.test(httpRequest))
+        if (!httpEvent) {
+          throw new Error(
+            `Serverless http event not found for HTTP request "${httpRequest}" in service path "${this.servicePath}".`
+          )
+        }
+
+        const parsedPath = ServerlessInvoker.parsePath(httpRequest)
+        event = Object.assign({}, event, {
+          path: parsedPath,
+          resource: parsedPath,
+          pathParameters: ServerlessInvoker.parsePathParameters(
+            httpEvent,
+            httpRequest
+          ),
+          queryStringParameters: ServerlessInvoker.parseQueryStringParameters(
+            httpRequest
+          ),
+          httpMethod: ServerlessInvoker.parseHttpMethod(httpRequest)
+        })
+
+        return this.loadServerlessEnvironment().then(() => {
+          return this.invokeWithLambdaWrapper(httpEvent, event, context)
+            .then(response => {
+              if (
+                response &&
+                response.headers &&
+                Object.keys(response.headers).includes("Content-Type") &&
+                response.headers["Content-Type"] === "application/json"
+              ) {
+                if (response.body && typeof response.body === "string") {
+                  response.body = JSON.parse(response.body)
+                }
+              }
+              return response
+            })
+            .catch(eLambdaFuncError => {
+              // In this situation API Gateway returns 502 (bad gateway) and sets the response body to `{"message": "Internal server error"}`. We are adding a bit more detail to the error.
+              console.error(
+                "serverless-http-invoker error invoking function:",
+                eLambdaFuncError
+              )
+              const response = {
+                statusCode: 502,
+                body: {
+                  message: "Internal server error",
+                  test_debug_error_message: eLambdaFuncError.toString(),
+                  test_debug_error_stack: eLambdaFuncError.stack
+                }
+              }
+              return response
+            })
+        })
+      })
+  }
+
+  static parseHttpMethod(httpRequest) {
+    const parts = httpRequest.split(" ")
+    assert(
+      parts.length >= 1,
+      "expected httpRequest to be a method seperated by a space and then the request path"
+    )
+    return parts[0]
+  }
+
+  static parsePathParameters(httpEvent, httpRequest) {
+    let pathParamValues = httpEvent.matcher.exec(httpRequest)
+    if (pathParamValues.length > 0) {
+      pathParamValues = pathParamValues.slice(1)
+    }
+    const pathParametersMap = {}
+    assert(
+      httpEvent.pathParamNames.length === pathParamValues.length,
+      `expected param names and param values to have same length, but were: \n\tnames: ${JSON.stringify(
+        httpEvent.pathParamNames
+      )}\n\t!==\n\tvalues: ${JSON.stringify(pathParamValues)}`
+    )
+    for (let i = 0; i < httpEvent.pathParamNames.length; i++) {
+      let paramName = httpEvent.pathParamNames[i]
+      pathParametersMap[paramName] = pathParamValues[i]
+    }
+    return pathParametersMap
+  }
+
+  static parseQueryStringParameters(requestUrl) {
+    const myURL = url.parse(
+      "https://fakehost.com/" + requestUrl.split(" ")[1],
+      true
+    )
+    const search =
+      myURL.search && myURL.search.length > 0
+        ? myURL.search.slice(1)
+        : myURL.search
+    return querystring.parse(search)
+  }
+
+  static parsePath(requestUrl) {
+    const myURL = url.parse("https://fakehost.com/" + requestUrl.split(" ")[1])
+    return myURL.pathname
+  }
+
+  loadServerlessEnvironment() {
+    return Promise.try(() => {
+      let env = this.serverless.service.provider.environment
+      Object.assign(process.env, env)
+      return env
+    })
+  }
+
+  invokeWithLambdaWrapper(httpEvent, event, context) {
+    return Promise.try(() => {
+      let handlerModule = require(path.join(
+        this.servicePath,
+        httpEvent.handlerPath
+      ))
+      let lambda = wrap(handlerModule, { handler: httpEvent.handlerName })
+      lambda = Promise.promisifyAll(lambda)
+      return lambda.runHandler(event, context || {})
+    })
+  }
+
+  loadServerlessEvents() {
+    let funcs = this.serverless.service
+      .getAllFunctions()
+      .map(fname => {
+        let funcObj = this.serverless.service.getFunction(fname)
+        let events = this.serverless.service.getAllEventsInFunction(fname)
+        let f = {
+          name: fname,
+          handler: funcObj.handler,
+          events: events.filter(
+            e => Object.keys(e).includes("http") && e.http !== null
+          )
+        }
+        return f
+      })
+      .filter(f => f.events.length > 0)
+      .map(f => {
+        f.events = f.events.map(evt => {
+          // add a path parser regex:
+          RegExp.escape = function(s) {
+            // https://stackoverflow.com/a/3561711/51061
+            return s.replace(/[-/\\^$*+?.()|[\]]/g, "\\$&")
+          }
+          let path = null
+          let method = null
+          if (typeof evt.http === "object") {
+            path = evt.http.path
+            method = evt.http.method
+          } else {
+            assert(
+              typeof evt.http === "string",
+              `Expected http event to have a type of object or string but was ${typeof evt.http}.`
+            )
+            method = evt.http.split(" ")[0]
+            path = evt.http.split(" ")[1]
+          }
+          let pattern = RegExp.escape(path)
+          // collect the pathParamNames:
+          //  first the "greedy" path params like {pname+} (with a '+' postfix)
+          let matchPathParamNamesPattern = pattern.replace(
+            /\/\{[^}]*\+\}/gi,
+            "/(.*)"
+          )
+          //  then the normal path params
+          matchPathParamNamesPattern = pattern.replace(
+            /\/\{[^}]*\}/gi,
+            "/([^/]*)"
+          )
+          let matchPathParamNames = new RegExp(matchPathParamNamesPattern, "gi")
+          let pathParamNames = matchPathParamNames.exec(path).slice(1) // the first element is full matched text so slice it off
+          // remove the surrounding bracket characters:
+          pathParamNames = pathParamNames.map(p =>
+            p.replace(/^\{([^}]+)\}$/, "$1")
+          )
+          // remove the '+' postfix if it exists
+          pathParamNames = pathParamNames.map(p =>
+            p.endsWith("+") ? p.substring(0, p.length - 1) : p
+          )
+          // console.log('pathParamNames:', pathParamNames, 'path:', path)
+          // now collect the values for the params:
+          let optionalQueryStringPattern = "(?:\\?.*)?$"
+          // first match greedy, then the normal ones again:
+          let matchPathParamValuesPattern = pattern.replace(
+            /\/\{[^}]*\+\}/gi,
+            "/(.+)"
+          )
+          matchPathParamValuesPattern = matchPathParamValuesPattern.replace(
+            /\/\{[^}]*\}/gi,
+            "/([^/\\?]+)"
+          )
+          let matcher = new RegExp(
+            "^" +
+              method +
+              "\\s+" +
+              matchPathParamValuesPattern +
+              optionalQueryStringPattern,
+            "i"
+          )
+          // console.log('path:', path, 'matcher:', matcher)
+          return Object.assign(evt.http, {
+            matcher: matcher,
+            pathParamNames: pathParamNames,
+            test: request => {
+              const result = matcher.test(request)
+              // console.log(`${method} ${path}: ${request} == ${result} \n  pattern:${matcher.source}`)
+              return result
+            }
+          })
+        })
+        return f
+      })
+
+    let events = []
+    for (let f of funcs) {
+      for (let e of f.events) {
+        e.function = f.name
+        e.handlerPath = f.handler.split(".")[0]
+        e.handlerName = f.handler.split(".")[1]
+        events.push(e)
+      }
+    }
+    return Promise.resolve(events)
+  }
+}
+
+module.exports = ServerlessInvoker

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "serverless-http-invoker",
+  "version": "1.0.9",
+  "description": "Locally invoke Serverless functions via their HTTP event as specified in Serverless.yml for testing.",
+  "main": "index.js",
+  "author": "Scott Willeke <scott@willeke.com> (https:/scott.willeke.com/)",
+  "license": "MIT",
+  "keywords": [
+    "serverless",
+    "serverless framework",
+    "serverless applications",
+    "serverless modules",
+    "api gateway",
+    "lambda",
+    "aws",
+    "aws lambda",
+    "amazon",
+    "amazon web services",
+    "serverless.com",
+    "mocha",
+    "test",
+    "testing",
+    "bdd",
+    "tdd"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/activescott/serverless-http-invoker.git"
+  },
+  "bugs": {
+    "url": "https://github.com/activescott/serverless-http-invoker/issues"
+  },
+  "scripts": {
+    "test": "nyc ./node_modules/.bin/mocha ./examples/**/*.spec.js",
+    "pretest": "npm run lint",
+    "lint": "prettier -l \"{,!(node_modules)/**/}*.{ts,tsx,js,jsx,md,yml,json,html}\"",
+    "lint-fix": "prettier --write \"{,!(node_modules)/**/}*.{ts,tsx,js,jsx,md,yml,json,html}\""
+  },
+  "dependencies": {
+    "lambda-wrapper": "^0.3.0"
+  },
+  "peerDependencies": {
+    "serverless": "^1.27.3"
+  },
+  "devDependencies": {
+    "chai": "^4.1.0",
+    "chai-as-promised": "^7.1.1",
+    "coveralls": "^3.0.4",
+    "mocha": "^8.3.2",
+    "nyc": "^15.0.0",
+    "prettier": "^1.18.2",
+    "serverless": "^2.46.0"
+  }
+}

package/pre-commit.sh

@@ -0,0 +1,11 @@
+# RUN `ln -sf ../../pre-commit.sh .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit` to set this up as the git pre-commit hook
+
+die () {
+  echo ""
+  echo "git pre-commit hook FAILED! See above for details."
+  echo ""
+	exit $@
+}
+
+npm run lint || die $?
+npm run test || die $?

package/release.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  // https://github.com/semantic-release/semantic-release/blob/beta/docs/usage/configuration.md
+  branches: [
+    "+([0-9])?(.{+([0-9]),x}).x",
+    "main",
+    "next",
+    "next-major",
+    { name: "beta", prerelease: true },
+    { name: "alpha", prerelease: true }
+  ]
+}

package/test/support/setup.js

@@ -0,0 +1,4 @@
+"use strict"
+const chai = require("chai")
+var chaiAsPromised = require("chai-as-promised")
+chai.use(chaiAsPromised)

package/test-data/no-serverless-found/.keep

@@ -0,0 +1 @@
+just to keep this directory here for a test.