Skip to main content

Yamas - Yet Another Mock API Server

Project description

Yamas - Yet Another Mock API Server

This project develops a simple mock API server for prototyping and testing client applications.

Based on http.server of Python3.6+, Yamas is a testing API server which can accept HTTP requests from a client and reply with pre-defined mock HTTP responses. (Note: Yamas should not be used for production.)

The mock responses and the rules of selecting them are specified in a JSON file. Processing an request, Yamas locates the wanted mock response by matching the request path with a sequence of user-specified regular expressions and then looking up the response by the request method.

Usage

Yamas has been published to PyPI. You can use pip to install Yamas:

pip install yamas

The command-line interface of Yamas is as follows:

yamas [-e|--endpoint host:port] -f|--file mock_responses_file
  • -e or --endpoint specifies the host address and the port number of the endpoint; if this is not specified, 127.0.0.1:7000 will be used.
  • -f or --file specifies the path of the JSON file which defines the mock responses and the selection rules.

For example,

yamas.py -e localhost:8000 -f mock_responses.json

To run Yamas using the source code under the project root directory (e.g., /home/yam/git/yamas):

export PYTHONPATH=/home/yam/git/yamas
bin/yamas

To run the tests:

python -m pytest tests/

Specification of mock responses

The mock responses and the rules of selecting them are specified in a JSON file, which is given on the command line. A sample specification is given as follows:

{
    "^/users/(\\w+)/todo/(\\d+)$": {
        "GET": {
            "status": 200,
            "content": {
                "user": "{0}",
                "taskid": "{1}",
                "task": "Buy milk",
                "pri": "low"
            },
            "contentType": "json",
            "interpolate": true
        },
        "DELETE": {
            "status": 410
        }
    },
    "^/users/\\w+/todo/?": {
        "GET": {
            "status": 200,
            "content": [
                "123",
                "456",
                "789"
            ],
            "contentType": "json"
        },
        "POST": {
            "content": {
                "taskid": "123"
            },
            "contentType": "json",
            "interpolate": false
        }
    },
    "^/users/(\\w+)/profile.xml$": {
        "GET": {
            "status": 200,
            "headers": {
                "Content-Type": "application/xml"
            },
            "content": "<profile><user>{0}</user><org>yam.ai</org><grade>premium</grade></profile>",
            "contentType": "text",
            "interpolate": true
        },
        "PUT": {
            "status": 409,
            "content": "object already updated",
            "contentType": "text"
        }
    }
}

The root level is a JSON object. Inside the root object, the keys are Python regular expressions and the associated values are JSON ojbects. The regular expressions are used to match the request path. The JSON object value specifies the mock responses for each HTTP method. The matching is done in the order of the keys specified in the file. In other words, a key is selected one by one from the top to the bottom and its regular expression is used to match the request path.

When the request path matches the regular expression of a key, the associated JSON object specifying the mock responses associated with the HTTP methods will be selected. When the request path does not match the regular expression, the regular expression in the next key will be selected. If the request path matches no regular expression, a 404 Not Found response will be replied.

When the request path matches the regular expression in a key, the corresponding JSON object value will be used to construct the response. Inside this JSON object, the keys are HTTP methods. The JSON object corresponding to each HTTP method key specifies a mock response.

The mock response object contains the following:

  • status specifies the status code of the response. If status is not specified, 200 OK will be used.
  • headers specifies a JSON object containing the header names and values. If there are no user-defined headers, headers can be omitted. If the value of a header is an empty string, the corresponding header, which may be automatically added, (e.g., Content-Type) will be remoed.
  • content specifies the content of the response. Its value should match its contentType.
  • contentType specifies the data type of the content. The following types can be used:
    • text: content must be a string of the UTF-8 text content. The header Content-Type: text/plain will be automatically added unless it is overriden by a user-specified Content-Type header.
    • json: content is treated as a JSON value. The header Content-Type: application/json will be automatically added unless it is overriden by a user-specified Content-Type header.
    • contentType is omitted: content is treated as a text type except the header Content-Type: text/plain is not automatically added.
  • interpolate specifies whether the matched values of the capturing groups in the request path will be inserted into the content. It is false by default. When interpolate is true, every string value in content is expected to be a Python format string. If content is text, the value is treated as a format string. If the content is json, every string value in the object is treated as a format string. In the first format string of the the above example, {0} will be substituted with the matched value of the first capturing group in the regular expression (i.e., (\w+)), {1} will be substituted with the value of the second matched capturing group (i.e., (\d+) ). Note the special characters, such as \, {, } in a regular expression needs to be escaped as \\, {{, }}.

Professional services

If you need any support or consultancy services from YAM AI Machinery, please find us at:

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for yamas, version 0.1.4
Filename, size File type Python version Upload date Hashes
Filename, size yamas-0.1.4.tar.gz (10.2 kB) File type Source Python version None Upload date Hashes View hashes

Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page