README

Flyback

Record, replay and mock HTTP requests. Flyback is a javascript HTTP recorder written in typescript. Can be used as standalone server or http middleware. It is created for use in your integration or e2e tests or running your application against mocked HTTP servers.

Installation

npm i flyback
yarn add flyback

Usage


const { createFlybackMiddleware, FlybackServer, RecordModes } = require("flyback");

const options = {
    proxyUrl: "https://api.service.com/v3/",
    recordMode: RecordModes.NEW,
    silent: true,
    summary: false,
    path: "./tapes",
    tapeFileExtension: 'json5'
};

const server = new FlybackServer(opts);

server.start();

// or

const middleware = createFlybackMiddleware(options);

Options:

Name	Type	Description	Default
proxyUrl	`String`	Where to proxy unknown requests
flybackUrl	`String`	Where to serve flyback server (ignored for middleware)	http://localhost:8080
tapesPath	`String`	Path where to load and save tapes	undefined
recordMode	`RecordMode \\| Function`	Set record mode. More info	`RecordMode.NEW`
fallbackMode	`FallbackMode \\| Function`	Fallback mode for unknown requests when recording is disabled. More info	`FallbackMode.NOT_FOUND`
tapeNameGenerator	`Function`	Customize how a tape file name is generated for new tapes.	`null`
tapePathGenerator	`Function`	Customize how a tape file path (to directory) is generated for new tapes.	`null`
tapeFileExtension	`String`	Tape file extension	`.json`
https	`Object`	HTTPS cert options options used to create https server in FlybackServer	null
agent	`https.Agent`	https.Agent for node-fetch to make requests to proxyUrl
ignoreQueryParams	`[String]`	Query params to ignore when matching tapes. Useful when having dynamic query params like timestamps	`[]`
ignoreAllQueryParams	`Boolean`	Ignore all query params when matching tapes.	`['content-length', 'host]`
checkHeaders	`[String]`	List of headers to check when matching tapes. Other headers are ignored. Useful when you want to check specific headers	`['x-user-role', 'host']`
ignoreHeaders	`[String]`	List of headers to ignore when matching tapes. Useful when having dynamic headers like cookies or correlation ids	`['content-length', 'host']`
ignoreAllHeaders	`[String]`	List of headers to ignore when matching tapes. Useful when having dynamic headers like cookies or correlation ids	`['content-length', 'host']`
ignoreBody	`Boolean`	Should the request body be ignored when matching tapes	`false`
tapeMatcher	`Function`	Customize how a request's body is matched against saved tapes. More info	`null`
tapeDecorator	`Function`	Decorate tapes when they are created. More info	`null`
summary	`Boolean`	Enable exit summary of new and unused tapes at exit. Printed when flyback server stoppped More info	`true`
verbose	`Boolean`	Enable requests information printing	`false`
debug	`Boolean`	Enable debug information	`false`

HTTPS options

Name	Type	Description	Default
keyPath	`String`	Path to the key file	`null`
certPath	`String`	Path to the cert file	`null`

Api

FlybackServer(options)

deprecated, will be removed in 4.0 returns server instance that can be started and closed

start([callback])

Starts the HTTP server.

close([callback])

Stops the HTTP server.

createFlybackMiddleware(options)

returns node middleware

createFlybackServer(options)

returns FlybackServer instance

create(options)

returns flyback instance with created server, middleware and tape usage statistics

Tapes

Tapes can be freely edited to match new requests or return a different response than the original. They are loaded recursively from the tapesPath directory at startup if specified.

tapesPath can be generated dynamically, you can take it from request header or cookie, it can be used in testing with puppeteer, you can add header with test path, and tapes will be loaded from directory near test files

Format

All tapes have the following 2 properties:

Request: Used to match incoming requests against the tape.

export type RequestJson = {
    pathname: string;
    query?: QueryParamsObject;
    method: string;
    headers: HeadersJson;
    body?: string | Object;
};

Response: The HTTP response that will be returned in case the tape matches a request.

export type ResponseJson = {
   status: number;
   headers: HeadersJson;
   body?: string | Object;
};

You can edit any part of the tape through tapeDecorator option.

Flyback doesn't watch tape files so if you will change them in runtime, changes wont be applied

Tape naming

Tape name by default generated from path, for /api/v3/data you will have api.v3.data.json tape name

Tapes can be renamed at will, for example to give some meaning to the scenario the tape represents.

If a custom tapeNameGenerator is provided, it will be called to produce an alternate file path under path that can be based on the tape contents. Note that the file extension .json will be appended automatically if need.

Grouping

Tapes with the same paths in directory will be grouped in tape file in case tapes don't match and record mode is NEW or OVERWRITE, tape file consist of tapes, you can edit it as regular tape.

Request and Response body

If the content type of the request or response is considered human readable, the body will be saved in plain text or plain object. It works even in case your content is gzipped or brottlied, it will uncompress your tapes before serialization and compress it before returning matching tape

Otherwise, the body will be saved as a Base64 string, allowing to save binary content.

Pretty Printing

If the request or response have a JSON content-type, their body will be pretty printed as an object in the tape for better readability. Two tapes with json bodies will be compared using deep equal tool, so order of keys in object doesn't matter

Recording Modes

Flyback proxying and recording behavior can be controlled through the recordMode option. This option accepts either one of the possible recording modes to be used for all requests or a function that takes the request as a parameter and returns a valid recording mode. There are 4 possible recording modes:

Value	Description
`NEW`	If no tape matches the request, proxy it and save the response to a tape
`OVERWRITE`	Always proxy the request and save the response to a tape, overwriting any existing one
`DISABLED`	If a matching tape exists, return it. Otherwise, don't proxy the request and use `fallbackMode` for the response
`PROXY`	Always proxy request and don't save any tapes

The fallbackMode option lets you choose what do you want flyback to do when recording is disabled and an unknown request arrives.

Same as with recordMode, this option accepts either one of the possible modes values to be used for all requests or a function that takes the request as a parameter and returns a mode.

There are 2 possible fallback modes:

Value	Description
`NOT_FOUND`	Log an error and return a 404 response
`PROXY`	Proxy the request to `host` and return its response, but don't create a tape

flyback exports constants for the different options values:


const { RecordModes, FallbackModes } = require("flyback")

const opts = {
    record: RecordModes.OVERWRITE,
    fallbackMode: FallbackModes.PROXY
}

Tape matcher

By default, in order for a request to match against a saved tape, both request and tape need to have the exact same body.

There might be cases were this rule is too strict (for example, if your body contains time dependent bits) but enabling ignoreBody is too lax.

flyback lets you pass a custom matching function as the tapeMatcher option.

Example:


const tapeMatcher = (tape: TapeJson, request: RequestJson) => {
    return tape.request.pathname === request.pathname 
            && tape.request.method === request.method
};

In this case we are matching tapes by their pathname and method

Tape decorator

If you want to change tape content before serializing it or before sending to server you can use the tapeDecorator option.

This can be useful for example if your response needs to contain an ID that gets sent on the request, or if your response has a time dependent field.

The function will receive a copy of the matching tape and it has to return the modified tape. Note that since you're receiving a copy of the matching tape, modifications that you do to it won't persist between different requests.

Example:

We're going to hit an /auth endpoint, and update just the expiration field of the JSON response that was saved in the tape to be a day from now.

const tapeDecorator = (tape: TapeJson) => {
     if (tape.request.headers.date) {
         tape.request.headers.data = new Date().toISOString();
     }
     
     return tape;
};

Inspiration

Talkback

Polly.js

Docker image

You can use docker image with flyback inside

docker pull gzaripov/flyback

provide your configuration file by mounting it into /usr/src/app/flyback-config.js

example of configuration file:

const path = require('path');
const { RecordModes } = require('flyback');

const CERT_PATH = path.resolve(__dirname, './flyback.cert.pem');

module.exports = {
    // use env variables for configuring image
    proxyUrl: process.env.FLYBACK_PROXY_URL,
    flybackUrl: process.env.FLYBACK_SERVER_URL,
    recordMode: RecordModes.DISABLED,
    https: {
        keyPath: CERT_PATH,
        certPath: CERT_PATH
    },
    ignoreAllHeaders: true,
    tapeFileExtension: 'json5'
};

Licence

MIT

Usage no npm install needed!

README

Flyback

Installation

Usage

HTTPS options

Api

FlybackServer(options)

start([callback])

close([callback])

createFlybackMiddleware(options)

createFlybackServer(options)

create(options)

Tapes

Format

Tape naming

Grouping

Request and Response body

Pretty Printing

Recording Modes

Tape matcher

Example:

Tape decorator

Example:

Inspiration

Docker image

Licence