DEV Community: Shubhendu Madhukar

File Based API Mocking in JavaScript

Shubhendu Madhukar — Mon, 25 Oct 2021 07:49:28 +0000

It's been a while, since I wrote about Camouflage. There have been some exciting developments in past few months and I would like to present the new features Camouflage has to offer to support your prototyping/testing needs.

What is Camouflage?

For the uninitiated, Camouflage is a mocking tool, used to stub the backends based on various protocols, such as http, https, http2, grpc and websockets.

Camouflage helps you carry out your front end prototyping, unit testing, functional/performance testing in silos, in absence of one or more Microservices/APIs. If you'd like to read more, visit my previous post

What's new in Camouflage?

Some of the things I have been working on for past few months are:

A fully customizable caching mechanism. Compared to earlier versions where cache was stored only in memory, you can now use redis for caching.
Connection to external data sources. Most mocking tools rely on random data such as names, uuids, random numbers etc to make your response dynamic. But sometimes, that's not enough. Even though you are just building a mock, you might at times, need to connect to a real data source instead of just random data. Camouflage supported CSV files as data source in previous versions, but now you can also use postgres as your data source. (MySQL/Mongo to be supported soon)
Containerization. Camouflage can now be deployed on docker environments, and kubernetes. Simply use the enclosed docker-compose.yml and kubernetes/*.yaml to quickly spin up a Camouflage environment

Full list of features

🔥 File based mocking support for HTTP, HTTPS, HTTP2, gRPC and websockets. 🔥

⚡ Dynamic/realistic responses without having to write any code. ⚡

🧩 Flexibility to partially or fully code your responses. 🧩

🎯 Conditional responses based on request parameters. 🎯

🌟 Inbuilt Caching - In memory and redis. 🌟

🧮 Ability to fetch and condition the response using external data. Currently supported data sources are CSV and postgres. 🧮

⏳ Delay Simulation. ⏳

🔍 Inbuilt monitoring. 🔍

🦺 Inbuilt backup and restore mechanism. 🦺

⏩ Quick start with camouflage init and camouflage restore modules. ⏩

🎊 Deployable on standalone VMs, Dockers and Kubernetes. 🎊

📁 Comes with a file explorer UI that allows modification of mock files hosted remotely. 📁

What is in works?

Camouflage is now reaching a stable state, which means a large part of effort would be focused on maintenance, resolving dependency vulnerability, cleaning up and commenting code, building an up-to-date JSDocs, supporting newer releases of Node (Camouflage can be run on systems with Node <v15).

New functionalities on the road map are introducing few more data source compatibility, breaking down Camouflage from one large package to smaller modules that can be used as plugins, and eventually migrating from express to fastify.

Check out the project @ Github. Leave a 🌟 if you'd like what you see, drop suggestions or ask questions, we'd love every bit of support we can get. To know all the details about Camouflage, refer to documentation

Mocking backends with Camouflage

Shubhendu Madhukar — Fri, 23 Apr 2021 00:07:52 +0000

In my previous post I introduced Camouflage as a mocking tool for HTTP backends. After a number of feedbacks, numerous tests and code optimisations, documentation proof reading and much more, Camouflage is now on its way to a stable release, with lots of new bells and whistles.

What are mocks?

Mocks or Stubs or Virtual Services, are replacements for your actual backend systems, which can be used for testing purposes in case your backend is unavailable. Mocks are great for several reasons:

You are building a frontend application but your backend isn't ready yet. Use mocks to quickly create a virtual backend which provides you a dummy response and lets you test your frontend application without actually hitting a backend. Once your backend is ready just replace the mock server host with the actual server host in your configs and everything else remains the same. No more reading static responses from files.
You can have similar use cases while running unit tests, functional tests or even performance tests, where as long as the virtual service can simulate the latency and provide a response similar to actual response, you don't need your complete backend and downstream to be ready for running tests in silos.
Mocks are also great for debugging purposes, when you are testing multiple microservices together. Even with advanced monitoring tools, sometimes it's hard to pinpoint the exact cause of the issue. With mocks you can plug and play and debug which component is causing problems. And assess if rest of your application stack will work fine if the problematic component wasn't so…problematic.

How do you create mocks?

While there are a lot many tools available in open source world that allow you to create mocks, however in this article I'll discuss a new tool I have been working on. Camouflage.

Camouflage works just as the name suggests. It allows you to create and use dummy backends. And your front end or dependant applications wouldn't be able to tell the difference if the response is coming from a mock or an actual API.

Though Camouflage isn't an original idea in it's essence, it has a lot of cool features and enhancements over existing tools that help you get up and running within seconds. Few of the prominent features are:

Camouflage has a near minimum learning curve. Create a directory mocks/hello-world. Place a file named GET.mock containing your raw HTTP Response. And you are done. Make a GET request to /hello-world and you get your expected response. Make any changes to the content of your .mock file name and you get the new response without any downtime.
Camouflage heavily uses handlebars, which enables you to add character to your response. Insert dynamic random values that change on each invocation, fetch data from incoming request and send out a conditional response, simulate delays and lot more.
Camouflage comes in two modes, functional and performance. By default Camouflage runs in functional mode, which is sufficient for unit tests, frontend testing, even a small scale performance test. However if your machine has multiple CPUs and you are planning to run a performance test, why not make use of the full potential of your machine. You can use performance mode which lets Camouflage utilise multiple CPUs using node's cluster module.
And finally, Camouflage supports multiple protocols, such as HTTP, HTTPS, HTTP2 and gRPC. More protocols are in development (i.e. TCP and SMTP)

Enough talk. How do we create a mock?

Well, you follow few simple steps:

Install Camouflage as a global package using your favourite package manager

npm install -g camouflage-server

Or,

yarn global add camouflage-server

Create a mocks directory which will contain all your mocks. e.g. ~/mocks
Create a config file. config.yml

loglevel: info
cpus: 1
monitoring:
  port: 5555
protocols:
  http:
    mocks_dir: "./mocks"
    port: 8080
  https:
    enable: false
    port: 8443
    cert: "./certs/server.cert"
    key: "./certs/server.key"
  http2:
    enable: false
    port: 8081
    cert: "./certs/server.cert"
    key: "./certs/server.key"
  grpc:
    enable: false
    host: "10.111.22.333"
    port: 4312
    mocks_dir: "./grpc/mocks"
    protos_dir: "./grpc/protos"

Start Camouflage: camouflage --config config.yml
Create another directory in the format your APIs basepath would be. For example: For an API http://localhost:8080/hello/world, create directories as ~/mocks/hello/world
Create a file ${HTTP_METHOD}.mock and insert your HTTP raw response. e.g vi ~/mocks/hello/world/GET.mock and paste following content. (If you are on windows, simply use notepad.)

HTTP/1.1 200 OK
X-Custom-Header: Custom-Value
Content-Type: application/json
{
     "greeting": "Hey! It works!"
}

And you are done, navigate to http://localhost:8080/hello/world, to see your mock in action.

Conclusion:

There are already a lot of mocking tools already available like Wiremock, mountebank etc. And those are really great tools, but in my experience, it took me sometime to familiarise myself with the tool, their JSON schema and other available options. The problem statement Camouflage tries to tackle is simple, how to shorten the learning curve and get started with mocks creation within seconds.

On more details on how to use Camouflage, visit the documentation. If you'd like to contribute, you can do so by reporting bugs, providing suggestions on what more protocols can be implemented and use cases to cover and finally by creating pull requests for the changes you'd like to see.

Happy Mocking!

How To Mock APIs In Seconds

Shubhendu Madhukar — Wed, 14 Apr 2021 00:51:25 +0000

If you are a part of a testing community in a microservices world, you would often come across challenges in terms of environment availability, resource constraints, clash in release cycles and what not.

Consider an example where you are testing the application A. During one of your test flows, application A makes a downstream call to application B. And guess what? For one or more of the many reasons, application B is unavailable. You end up waiting for application B even though, it is just a dependency that you are not even testing.

In these scenarios, you can use a mock API to act as a stand in for application B and provide application A with dummy responses so that you can continue your tests without any dependency on the downstream.

What are HTTP mocks?

HTTP Mocks or Stubs, are replacements for your actual APIs, which can be used for testing purposes. Mocks are great for several reasons:

You are building a frontend application but your backend isn't ready yet. Use mocks to quickly create an API which provides you a dummy response and test your frontend application without actually hitting a backend. Once your backend is ready just replace the mock server host with the actual server host in your configs and everything else remains the same.
You can have similar use cases while running unit tests, functional tests or even performance tests, where as long as the mock API can simulate the latency and provide a response similar to actual response, you don't need your complete backend and downstream to be ready for running tests in silos.
Mocks are also great for debugging purposes, when you are testing multiple microservices together. Even with advanced monitoring tools, sometimes it's hard to pinpoint the exact cause of the issue. With mocks you can plug and play and debug which component is causing problems

How do you create mocks?

While there are a lot many tools available in open source world that allow you to create mocks, in this article I'll discuss a new tool I have been working on. Camouflage.

Camouflage works just as the name suggests. It allows you to create and use dummy APIs. And your front end or dependant applications wouldn't be able to tell the difference if the response is coming from a mock or an actual API.

Though Camouflage isn't an original idea (mockserver already implemented something similar), it has a lot of cool features and enhancements over existing tools that help you get up and running within seconds. Few of the prominent features are:

Camouflage has a near minimum learning curve. Create a directory mocks/hello-world. Place a file named GET.mock containing your raw HTTP Response. And you are done. Make a GET request to /hello-world and you get your expected response.
Camouflage heavily uses handlebars, which enables you to add character to your response. Insert dynamic random values that change on each invocation, fetch data from incoming request and send out a conditional response, simulate delays and lot more.
Camouflage comes in two modes, functional and performance. By default Camouflage runs in functional mode, which is sufficient for unit tests, frontend testing, even a small scale performance test. However if your machine has multiple CPUs and you are planning to run a performance test, why not make use of the full potential of your machine. You can use performance mode which lets Camouflage utilise multiple CPUs using node's cluster module.

Enough talk. How do we create a mock?

Well, you follow five simple steps:

Install Camouflage: npm install -g camouflage-server
Create a mocks directory which will contain all your mocks. e.g. ~/mocks
Start Camouflage: camouflage -m ~/mocks
Create another directory in the format your APIs basepath would be. For example: For an API http://localhost:8080/hello/world, create directories as ~/mocks/hello/world
Create a file ${HTTP_METHOD}.mock and insert your HTTP raw response. e.g vi ~/mocks/hello/world/GET.mock and paste following content. (If you are on windows, simply use notepad.)

HTTP/1.1 200 OK
X-Custom-Header: Custom-Value
Content-Type: application/json
{
     "greeting": "Hey! It works!"
}

And you are done, navigate to http://localhost:8080/hello/world, to see your mock in action.

Conclusion

Learn more:
Documentation
Source Code