During server software development (i.e. node) I always strive to work offline, in that my development workflow doesn't depend on any online services.
However, sometimes that's not possible as there's some 3rd party API dependancy - as there was in my latest client work. The problem I found, was that the latency between my location and the 3rd party API was so high, that it was impacting on the workflow cycle of: debug, change, test, repeat. The load time was taking anywhere from 15-30 seconds each time.
So this was my quick work around to easily mock out the API so my development process could be faster.

READER DISCOUNTSave $50 on terminal.training
I've published 38 videos for new developers, designers, UX, UI, product owners and anyone who needs to conquer the command line today.
$49 - only from this link
The aims
The aim was to, without much work at all, replicate specific API calls without modifying my application code. i.e. I could switch my mock API on and off as I needed.
It was also important that the time required to put a mock API in place, did not outweigh the time lost on the latency. Specifically, if the custom mock API turned into days of work, it would have been a total waste of time.
The simple solution
This code uses Express 4. It's entirely possible that there was a library that already existed, but the small amount of code that I had to write wins over finding, researching, checking and learning a new library.
Capturing mock data
First I had to run my way through each API call and save the raw output as a .json
file in a local directory (not tracked in git) called mock-data
.
Since all my internal API calls used a config value as the root of the API URL, it meant I could change my local config to point to my local mock API instead of the staging or production endpoint:
var config = require('./config');
var root = config.api;
function getOrder(id) {
return request({ // a promise
url: root + '/order',
type: 'json',
body {
id: id
}
});
}
I would change my config.api
value to point to `http://localhost/mock-api' and the server I was developing would actually reply to the API requests using the code in the next section.
Mock API Code
The following code would be in (something like) routes/mock-api.js
:
var express = require('express');
var fs = require('fs');
var router = express.Router();
// directory path to the mock json files
var mockPath = __dirname + '/mock-data/';
var design = {
'POST /order': 'getOrder',
'POST /order/tickets': 'addTickets',
'DELETE /order/tickets': 'removeTicket',
}
module.exports = router;
Object.keys(design).forEach(function (req) {
var method = req.split(' ').shift();
var path = req.split(' ').pop();
var mock = '{}';
try {
mock = require(mockPath + design[req]);
} catch (e) {}
router.route(path)[method.toLowerCase()](function (req, res) {
res.send(mock);
});
});
In my main routes.js
file I can then conditionally load up my mock router:
// snip...
if (config.mock) {
app.use('/mock-api', require('./routes/mock-api'));
}
Now requests to my server (the same server I'm doing my main development against), can respond to API requests with pre-baked data. Now my damn latency is a thing of the past!
Taking it further
I struggle to look at the above code without seeing ways to improve it - but as I pointed out in the aims: keep it simple, and keep the solution quick.
Here's a few ideas that spring to mind that might make the code more useful in different situations:
- Respond with different file types (rather than only
.json
) - Respond with inline JSON data (that would be defined in the
design
) - Support variables in the URL to pick different static responses (like
GET /order/:id
)
I have done some similar work in my static server which also has limited support for interpolation in the response.
For now though, this simple version suits my requirements!