⚡️ Backend tests faster than unit tests, from user traffic ⚡️

🌟 The must-have tool for developers in the AI-Gen era 🌟

🎤 Introducing Keploy 🐰

Keploy is a developer-centric backend testing tool. It makes backend tests with built-in-mocks, faster than unit tests, from user traffic, making it easy to use, powerful, and extensible. 🛠

Ready for the magic? Here are Keploy's core features:

• ♻️ Combined Test Coverage: Merge your Keploy Tests with your fave testing libraries(JUnit, go-test, py-test, jest) to see a combined test coverage.

• 🤖 EBPF Instrumentation: Keploy uses EBPF like a secret sauce to make integration code-less, language-agnostic, and oh-so-lightweight.

• 🌐 CI/CD Integration: Run tests with mocks anywhere you like—locally on the CLI, in your CI pipeline, or even across a Kubernetes cluster. It's testing wherever you want it!

• 🎭 Multi-Purpose Mocks: Use 'em in existing tests, as server tests, or just to impress your friends!

• 📽️ Record-Replay Complex Flows: Keploy can record and replay complex, distributed API flows as mocks and stubs. It's like having a time machine for your tests—saving you tons of time!

🐰 Fun fact: Keploy uses itself for testing! Check out our swanky coverage badge:  

🌐 Language Support

From Go's gopher 🐹 to Python's snake 🐍, we support:

🎩 How's the Magic Happen?

Our magical 🧙‍♂️ Keploy proxy captures and replays ALL(CRUD operations, including non-idempotent APIs) of your app's network interactions.

Take a journey to How Keploy Works? to discover the tricks behind the curtain!

📘 Get Schooled!

Become a Keploy pro with our Documentation.

🛠️ Platform-Specific Requirements for Keploy

Below is a table summarizing the tools needed for both native and Docker installations of Keploy on MacOS, Windows, and Linux:

Operating System	Without Docker	Docker Installation
MacOS		Use Colima
Windows	Use WSL	Use WSL
Linux

On MacOS and Windows, additional tools are required for Keploy due to the lack of native eBPF support.

🚀 Quick Installation

To get started let's set Keploy alias by running.

 curl -O https://raw.githubusercontent.com/keploy/keploy/main/keploy.sh && source keploy.sh

Capturing Testcases

To initiate the recording of API calls, execute this command in your terminal:

keploy record -c "CMD_TO_RUN_APP" 

For example, if you're using a simple Golang program, the CMD_TO_RUN_APP would resemble:

keploy record -c "go run main.go"

Running Testcases

To run the testcases and generate a test coverage report, use this terminal command:

keploy test -c "CMD_TO_RUN_APP" --delay 10

Record-Replay on Docker

Recording Testcases and Data Mocks

Here are a few points to consider before recording!

• If you're running via docker-compose, ensure to include the <CONTAINER_NAME> under your application service in the docker-compose.yaml file like this.
• You must run all of the containers on the same network when you're using docker run command (you can add your custom network name using --network flag in docker run command).
• In your Docker Compose file, every container should run on the same network.
• Docker_CMD_to_run_user_container refers to the Docker command for launching the application.
• Add the required commands to your DockerFile as stated below.

...
# Download the ca.crt file
RUN curl -o ca.crt https://raw.githubusercontent.com/keploy/keploy/main/pkg/proxy/asset/ca.crt

RUN curl -o setup_ca.sh https://raw.githubusercontent.com/keploy/keploy/main/pkg/proxy/asset/setup_ca.sh

# Give execute permission to the setup_ca.sh script
RUN chmod +x setup_ca.sh
...

# Run the CA setup script and then run the application server
CMD ["/bin/bash", "-c", "source ./setup_ca.sh && <your app running command>"]

Note: Also add curl installation command if curl is not installed on your image

To capture test cases, Execute the following command within your application's root directory.

keploy record -c "Docker_CMD_to_run_user_container --network <network_name>" --containerName "<container_name>"

Perform API calls using tools like Hoppscotch, Postman, or cURL commands.

Keploy will capture the API calls you've conducted, generating test suites comprising test cases (KTests) and data mocks (KMocks) in YAML format.

Running Testcases

To execute the test cases, follow these steps in the root directory of your application.

When using docker-compose to start the application, it's important to ensure that the --containerName parameter matches the container name in your docker-compose.yaml file.

keploy test -c "Docker_CMD_to_run_user_container --network <network_name>" --containerName "<container_name>" --delay 20

Voilà! 🧑🏻‍💻 We have the tests with data mocks running! 🐰🎉

You'll be able to see the test cases that ran with the results report on the console as well as locally in the testReport directory.

🤔 Questions?

Reach out to us. We're here to help!

If You Had Fun: Please leave a 🌟 star on this repo! It's free, and you'll bring a smile. 😄 👏

💖 Let's Build Together!

Whether you're a newbie coder or a wizard 🧙‍♀️, your perspective is golden. Take a peek at our:

📜 Contribution Guidelines

❤️ Code of Conduct

🐲 The Challenges We Face!

• Unit Testing: While Keploy is designed to run alongside unit testing frameworks (Go test, JUnit..) and can add to the overall code coverage, it still generates integration tests.
• Production Lands: Keploy is currently focused on generating tests for developers. These tests can be captured from any environment, but we have not tested it on high volume production environments. This would need robust deduplication to avoid too many redundant tests being captured. We do have ideas on building a robust deduplication system #27

✨ Resources!

🤔 FAQs

🕵️‍️ Why Keploy

⚙️ Installation Guide

📖 Contribution Guide