Keploy

Keploy is a no-code testing platform that generates tests from API calls.

It converts API calls into testcases. Mocks are automatically generated with the actual request/responses.

Features

Generates test cases from API calls. Say B-Bye! to writing unit and API test cases.

Native interoperability with popular testing libraries like go-test. Code coverage will be reported with existing and Keploy recorded test cases and can also be integrated in CI pipelines/infrastructure.

Other Features

• Automatically mock network/external dependencies with correct responses. No more manually writing mocks for dependencies like DBs, internal services, or third party services like twilio, shopify or stripe.
• Safely replay writes or mutations by capturing from local or other environments. Idempotency guarantees are also not required in the application. Multiple Read after write operations can be replicated automatically too.
• Accurate noise detection in responses like (timestamps, random values) to ensure high quality tests.
• Statistical deduplication ensures that redundant testcases are not generated. We're planning to make this more robust (ref #27).
• Web Console to visually understand the results, update behaviour and share findings across your team.
• Automatic instrumentation for popular libraries/drivers like sql, http, grpc, etc.
• Instrumentation/Integration framework to easily add the new libraries/drivers with ~100 lines of code.

How it works?

Note: You can generate test cases from any environment which has all the infrastructure dependencies setup. Please consider using this to generate tests from low-traffic environments first. The deduplication feature necessary for high-traffic environments is currently experimental.

Installation

Start keploy server

git clone https://github.com/keploy/keploy.git && cd keploy
docker-compose up

The UI can be accessed at http://localhost:8081

Keeping keploy up-to-date

docker-compose pull

Integrate the SDK

Install the Go SDK with

go get -u github.com/keploy/go-sdk

Example

Sample application

You can try out the sample application with the go SDK integrated here

Routers

Example of integrating the gin router. Other routers like echo, chi, etc are support too.

import (
        "github.com/gin-gonic/gin"
        "github.com/keploy/go-sdk/integrations/kgin/v1"
        "github.com/keploy/go-sdk/keploy"
        )

r := gin.New()
port := "6060"

k := keploy.New(keploy.Config{
    App: keploy.AppConfig{
        // your application
        Name: "my-app",
        Port: port,
    },
    Server: keploy.ServerConfig{
        URL: "http://localhost:8081/api",
    },
})
//Call kgin.GinV1 before routes handling
kgin.GinV1(k, r)

r.Run(":" + port)

Datastore

Example of integrating the official mongo driver. Other datastore/database libraries like go's sql

import (
        "go.mongodb.org/mongo-driver/mongo"
        "github.com/keploy/go-sdk/integrations/kmongo"
        )

db  := client.Database("MyDB")

// wrap collection with keploy for automatic instrumentation and mocking
col := kmongo.NewCollection(db.Collection("MyCollection"))

Thats it! All the requests after integration will be automatically captured and available it at http://localhost:8081/testlist

Integration with native go test framework

You just need 3 lines of code in your unit test file and that's it!!🔥🔥🔥

import (
	"github.com/keploy/go-sdk/keploy"
	"testing"
)

func TestKeploy(t *testing.T) {
	keploy.SetTestMode()
	go main()
	keploy.AssertTests(t)
}

Language Support

• Go SDK

• Need another language support? Please raise an issue or discuss on our slack channel

Development

There's a separate docker-compose file which helps with exposing the mongo server and also builds the dockerfile from local code. The build flag ensures that the binary is built again to reflect the latest code changes. There's also docker-compose-debug.yaml which can help remote debugging the go server on port 40000.

docker-compose -f docker-compose-dev.yaml up --build

If you are not using docker, you can build and run the keploy server directly. Ensure to provide the Mongo connection string via the KEPLOY_MONGO_URI env variable.

export KEPLOY_MONGO_URI="mongodb://mongo:27017"
go run cmd/server/main.go

Keploy exposes GraphQL API for the frontend based on gqlgen. After changing the schema you can autogenerate graphQL handlers using

go generate ./...

Community support

We'd love to collaborate with you to make Keploy great. To get started:

• Slack - Discussions with the community and the team.
• GitHub - For bug reports and feature requests.