Popularity
1.9
Growing
Activity
5.9
-
115
11
6

Description

Cornell provides a lightweight record and replay server that can be easily used during distributed system testing and simulate all HTTP traffic needed for your tests.

Programming language: Python
License: MIT License
Tags: Testing     Mock     Proxy Servers     Python    

Cornell alternatives and similar packages

Based on the "Mock" category.
Alternatively, view cornell alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of Cornell or a related project?

Add another 'Mock' Package

README

Cornell: record & replay mock server

Build Status Python Version

Cornell makes it dead simple, via its record and replay features to perform end-to-end testing in a fast and isolated testing environment.

When your application integrates with multiple web-based services, end-to-end testing is crucial before deploying to production. Mocking is often a tedious task. It becomes even more tiresome when working with multiple APIs from multiple vendors.

vcrpy is an awesome library that records and replays HTTP interactions for unit tests. Its output is saved to reusable "cassette" files.

By wrapping vcrpy with Flask, Cornell provides a lightweight record and replay server that can be easily used during distributed system testing and simulate all HTTP traffic needed for your tests.

Basic Use Case

When you're working with distributed systems, the test client entry point triggers a cascade of events that eventually send HTTP requests to an external server

System in test

With Cornell server started, it will act as a proxy (record mode) between the outgoing HTTP requests and the external server and will record all relevant interactions. Once interactions are recorded, Cornell can work in replay mode, replacing the external server entirely, short-circuiting the calls and instead, replying back instantly with the previously recorded response.

System in test

Installation

To install from PyPI, all you need to do is this:

  pip install cornell

Usage

Usage: cornell_server.py [OPTIONS]

  Usage Examples: Record mode: `cornell --forward_uri="https://remote_server/api" --record -cd custom_cassette_dir`
  Replay mode: `cornell -cd custom_cassette_dir

Options:
  -p, --port INTEGER
  -ff, --forward_uri TEXT         Must be provided in case of recording mode
  -, --record-once / --record-all
                                  Record each scenario only once, ignore the
                                  rest

  -r, --record                    Start server in record mode
  -fp, --fixed-path               Fixed cassettes path. If enabled, Cornell
                                  will support only one server for recording

  -cd, --cassettes-dir TEXT       Cassettes parent directory, If not
                                  specified, Cornell parent dir will be used

  --help                          Show this message and exit.

Demo - Full Example

Staring Cornell in record mode:

cornell -ff https://api.github.com/ --record -cd cassettes

This will start the server in record-proxy mode on port 9000, and will forward all requests to https://api.github.com/

Cornell demo

When cornell is in record mode, it will forward all request to the specified forwarding URL, for example:

requests.get("http://127.0.0.1:9000/github/repos/kevin1024/vcrpy/license").json()

or

requests.get("http://127.0.0.1:9000/github/repos/kevin1024/vcrpy/contents").json()

or you can browse to the URL using your browser

Browser

Cornell will forward the request to the specified URL and will record both the request and the response.

The yaml cassettes will be recorded to a dedicated directory (by default, cassettes in the root dir)

For example:

Cassette dir

Note

By default, `cassettes` directory will be created in cornell's root dir and will contain the cassette by destination hierarchy.
Use `-cd` to specify custom directory for your cassettes.
Mind that `-cd <custom_dir> should match for both record and replay modes

Once all the necessary interactions were recorded, stop cornell server using ctrl+c. Once stopped, all interactions will be mapped via an auto-generated index.yaml file.

Note

In case the `index.yaml` is already present, it will be updated with new interactions. Otherwise, a new file will be created.

In this specific example, we can see that the 2 requests are mapped to the saved cassettes:

Index file

Features

Request Matchers

In addition to the vcrpy matchers, cornell provides the following custom request matchers:

  • OData request query matcher
  • SOAP request body matcher

Environment Variables

Since Cornell is a testing server it's executed by default with FLASK_ENV=local. You can modify this as described in flask configuration

Advanced Features

Can be found in the documentation

Contributing

Yes please! contributions are more than welcome!

Please follow PEP8 and the Python Naming Conventions

Add tests when you're adding new functionality and make sure all the existing tests are happy and green :)

To set up development environment:

  python -m venv venv
  source venv/bin/activate
  make configure

Running Tests

To run tests, run the following command

  python -m venv venv
  source venv/bin/activate
  make test


*Note that all licence references and agreements mentioned in the Cornell README section above are relevant to that project's source code only.