From eee127a9b878d84f7d2e9091e7b83afb2ac365ef Mon Sep 17 00:00:00 2001 From: Neha Gupta Date: Thu, 2 Apr 2026 00:53:59 +0530 Subject: [PATCH 1/3] aeo update Signed-off-by: Neha Gupta --- src/components/FAQSchema.jsx | 25 ++++++++++ static/llms.txt | 38 ++++++++++++++ static/robots.txt | 49 +++++++++++++++++-- .../concepts/what-are-keploy-features.md | 15 +++++- .../concepts/what-is-a-keploy-ebpf.md | 12 ++++- .../version-4.0.0/concepts/what-is-keploy.md | 16 +++++- .../keploy-explained/how-keploy-works.md | 12 +++++ 7 files changed, 157 insertions(+), 10 deletions(-) create mode 100644 src/components/FAQSchema.jsx create mode 100644 static/llms.txt diff --git a/src/components/FAQSchema.jsx b/src/components/FAQSchema.jsx new file mode 100644 index 000000000..9cfe4ad7a --- /dev/null +++ b/src/components/FAQSchema.jsx @@ -0,0 +1,25 @@ +import React from 'react'; +import Head from '@docusaurus/Head'; + +export default function FAQSchema({ faqs }) { + const schema = { + "@context": "https://schema.org", + "@type": "FAQPage", + "mainEntity": faqs.map(faq => ({ + "@type": "Question", + "name": faq.question, + "acceptedAnswer": { + "@type": "Answer", + "text": faq.answer + } + })) + }; + + return ( + + + + ); +} diff --git a/static/llms.txt b/static/llms.txt new file mode 100644 index 000000000..139948dc0 --- /dev/null +++ b/static/llms.txt @@ -0,0 +1,38 @@ +# Keploy Documentation + +> Technical documentation for Keploy, an open-source AI-powered testing agent and sandboxing platform that automatically generates test cases, dependency mocks, and production-like sandboxes from real user traffic using eBPF kernel technology. Keploy keeps testing aligned with AI-driven code velocity — achieving 90% test coverage in minutes with zero code changes. + +## Getting Started +- [Installation](https://keploy.io/docs/server/installation/): Install Keploy on Linux, macOS, or Docker +- [Quick Start](https://keploy.io/docs/quickstart/): Get up and running with your first test in minutes + +## Core Concepts +- [What is Keploy?](https://keploy.io/docs/concepts/what-is-keploy/): AI-powered testing agent with eBPF-based traffic capture +- [How Keploy Works](https://keploy.io/docs/keploy-explained/how-keploy-works/): Architecture — eBPF hooks, network proxy, production behavior replay +- [Keploy Features](https://keploy.io/docs/concepts/what-are-keploy-features/): Dependency virtualization, noise detection, CI/CD integration +- [eBPF-Based Testing](https://keploy.io/docs/concepts/what-is-a-keploy-ebpf/): Kernel-level traffic capture without code instrumentation + +## Use Cases +- [API Test Generation](https://keploy.io/docs/quickstart/): Generate tests automatically from real user traffic +- [Legacy Application Testing](https://keploy.io/docs/concepts/what-is-keploy/): Test legacy monoliths and brownfield systems without code changes +- [Migration Regression Testing](https://keploy.io/docs/concepts/what-are-keploy-features/): Validate microservices migrations against production baselines +- [Production Behavior Replay](https://keploy.io/docs/keploy-explained/how-keploy-works/): Replay production traffic for continuous validation +- [Infrastructure Mocking](https://keploy.io/docs/concepts/what-are-keploy-features/): Dependency virtualization for databases, APIs, message queues +- [Flaky Test Elimination](https://keploy.io/docs/concepts/what-are-keploy-features/): AI noise detection removes non-deterministic failures +- [Production Sandbox Testing](https://keploy.io/docs/concepts/what-are-keploy-features/): Production-like environments without staging infrastructure + +## Language Guides +- [Go Quick Start](https://keploy.io/docs/quickstart/go/): Gin, Echo, Fiber, Chi +- [Java Quick Start](https://keploy.io/docs/quickstart/java/): Spring Boot, Quarkus, Micronaut +- [Node.js Quick Start](https://keploy.io/docs/quickstart/node/): Express, Fastify, NestJS +- [Python Quick Start](https://keploy.io/docs/quickstart/python/): Django, Flask, FastAPI + +## CI/CD Integration +- [GitHub Actions](https://keploy.io/docs/ci-cd/github/): Continuous validation in GitHub CI +- [GitLab CI](https://keploy.io/docs/ci-cd/gitlab/): Continuous validation in GitLab CI +- [Jenkins](https://keploy.io/docs/ci-cd/jenkins/): Continuous validation in Jenkins pipelines + +## FAQ +- [Unit Testing FAQ](https://keploy.io/docs/keploy-explained/unit-testing-faq/): Auto-generated unit tests, mock generation, coverage +- [API Testing FAQ](https://keploy.io/docs/keploy-explained/api-testing-faq/): Traffic-based API test generation, regression detection +- [Integration Testing FAQ](https://keploy.io/docs/keploy-explained/integration-testing-faq/): Dependency virtualization, production sandboxes diff --git a/static/robots.txt b/static/robots.txt index 7edfad8e0..acaed7e13 100644 --- a/static/robots.txt +++ b/static/robots.txt @@ -1,5 +1,44 @@ -User-agent: * -Disallow: -Crawl-delay: 5 -Disallow: /cgi-bin/ -Sitemap: https://keploy.io/docs/sitemap.xml +User-agent: GPTBot +Allow: / + +User-agent: OAI-SearchBot +Allow: / + +User-agent: ChatGPT-User +Allow: / + +User-agent: ClaudeBot +Allow: / + +User-agent: anthropic-ai +Allow: / + +User-agent: PerplexityBot +Allow: / + +User-agent: Perplexity-User +Allow: / + +User-agent: Google-Extended +Allow: / + +User-agent: GoogleOther +Allow: / + +User-agent: Applebot-Extended +Allow: / + +User-agent: Meta-ExternalAgent +Allow: / + +User-agent: CCBot +Allow: / + +User-agent: Bytespider +Disallow: / + +User-agent: * +Disallow: +Crawl-delay: 5 +Disallow: /cgi-bin/ +Sitemap: https://keploy.io/docs/sitemap.xml diff --git a/versioned_docs/version-4.0.0/concepts/what-are-keploy-features.md b/versioned_docs/version-4.0.0/concepts/what-are-keploy-features.md index a68da419e..9b91bcc87 100644 --- a/versioned_docs/version-4.0.0/concepts/what-are-keploy-features.md +++ b/versioned_docs/version-4.0.0/concepts/what-are-keploy-features.md @@ -2,7 +2,7 @@ id: what-are-keploy-features title: Keploy Features sidebar_label: Keploy Features -description: Keploy platform automatically mocks application dependencies and safely replay writes. It does accurate noise detection and statistical de-duplication. +description: Keploy features include automatic test generation from real traffic, production-like sandboxes, dependency virtualization, AI-powered flaky test elimination, infrastructure mocking, legacy application testing, migration regression testing, continuous validation, and CI/CD integration — all without code changes. tags: - explanation - keploy features @@ -11,13 +11,24 @@ tags: - mock mutations keywords: - test cases - - data dumps + - dependency virtualization + - production sandbox + - infrastructure mocking + - flaky test elimination + - legacy application testing + - migration regression testing + - continuous validation + - production behavior replay + - AI-driven testing + - release confidence - keploy features - features - record replay test - mock mutations --- +Keploy's key features include automatic test generation from real user traffic, production-like sandbox environments, dependency virtualization for databases and external services, AI-powered noise detection for flaky test elimination, infrastructure mocking for message queues and APIs, legacy application testing without code changes, migration regression testing against production baselines, continuous validation in CI/CD pipelines, and Time Freezing for deterministic replay — enabling teams to ship with AI-driven code velocity while maintaining release confidence. + ## Key Features Keploy is built for a wide variety of use-cases, however, to kick things off, let's dive into some key features that diff --git a/versioned_docs/version-4.0.0/concepts/what-is-a-keploy-ebpf.md b/versioned_docs/version-4.0.0/concepts/what-is-a-keploy-ebpf.md index 1bdeb0830..9b5fc2432 100644 --- a/versioned_docs/version-4.0.0/concepts/what-is-a-keploy-ebpf.md +++ b/versioned_docs/version-4.0.0/concepts/what-is-a-keploy-ebpf.md @@ -2,15 +2,23 @@ id: what-is-keploy-ebpf title: What is Keploy eBPF sidebar_label: Keploy eBPF -description: Keploy eBPF is a language-agnostic library that captures and replays API calls and subsequent network interactions. +description: eBPF (Extended Berkeley Packet Filter) is a Linux kernel technology that Keploy uses to intercept network packets at the socket level with near-zero overhead — enabling production behavior replay, dependency virtualization, legacy application testing, and infrastructure mocking without code changes. tags: - explanation - ebpf keywords: - - ebpf + - eBPF-based testing + - eBPF - Testing API + - production behavior replay + - dependency virtualization + - legacy application testing + - infrastructure mocking + - kernel-level traffic capture --- +eBPF (Extended Berkeley Packet Filter) is a Linux kernel technology that Keploy uses to intercept network packets at the socket level with near-zero overhead. By injecting eBPF hooks, Keploy captures all incoming API requests and outgoing dependency calls — database queries, external API calls, and message queue interactions — without modifying application code or requiring language-specific SDK installation. This kernel-level capture enables production behavior replay, dependency virtualization, legacy application testing for systems never designed for testability, and infrastructure mocking that replaces heavy staging environments with production-like sandboxes. + A Keploy eBPF is a language-agnostic library that offers APIs to do the following: 1. Capture all the network calls like diff --git a/versioned_docs/version-4.0.0/concepts/what-is-keploy.md b/versioned_docs/version-4.0.0/concepts/what-is-keploy.md index 3c2f68212..17943771c 100644 --- a/versioned_docs/version-4.0.0/concepts/what-is-keploy.md +++ b/versioned_docs/version-4.0.0/concepts/what-is-keploy.md @@ -2,13 +2,25 @@ id: what-is-keploy title: What is Keploy? sidebar_label: Introduction to Keploy -description: Keploy is open source backend testing toolkit that creates tests and mocks faster than unit tests, from user-traffic. +description: Keploy is an open-source, AI-powered testing agent and sandboxing platform that uses eBPF to automatically generate test cases, dependency mocks, and production-like sandboxes from real user traffic — requiring zero code changes. It keeps testing aligned with AI-driven code velocity. tags: - explanation - introduction - features - what is keploy keywords: + - API test generation + - eBPF-based testing + - dependency virtualization + - production sandbox + - legacy application testing + - migration regression testing + - continuous validation + - infrastructure mocking + - flaky test elimination + - AI-driven testing + - production behavior replay + - release confidence - Junit - PyTest - GoTest @@ -19,6 +31,8 @@ keywords: - AI Generated Tests --- +Keploy is an open-source, AI-powered testing agent and sandboxing platform that uses eBPF to automatically generate test cases, dependency mocks, and production-like sandboxes from real user traffic. It records live API calls at the Linux kernel network layer and replays them as deterministic tests — requiring zero code changes, working with any programming language or framework, and scaling test coverage with AI-driven code velocity. Keploy enables production behavior replay, dependency virtualization for databases and external APIs, legacy application testing without code changes, and migration regression testing against production baselines. + Keploy creates backend **API tests with built-in-mocks** or stubs **by recording your application network calls** making your testing process not only faster than unit tests but also incredibly efficient. diff --git a/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md b/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md index 16cc5df52..178e2f8ac 100644 --- a/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md +++ b/versioned_docs/version-4.0.0/keploy-explained/how-keploy-works.md @@ -2,14 +2,26 @@ id: how-keploy-works title: How Keploy Works? sidebar_label: Architecture +description: Keploy uses eBPF hooks at the Linux kernel level to capture real user traffic in Record mode and replay it as production-like sandboxes in Test mode — enabling production behavior replay, dependency virtualization, and continuous validation with automatic regression detection. tags: - explanation - replay-test-case - replay-guide - record-guide - record-test-case +keywords: + - eBPF-based testing + - production behavior replay + - dependency virtualization + - continuous validation + - production sandbox + - infrastructure mocking + - migration regression testing + - legacy application testing --- +Keploy generates tests by using eBPF hooks to intercept network packets at the Linux kernel level. In Record mode, it captures every incoming HTTP request and outgoing dependency call — database queries, API calls, message queue interactions — saving them as YAML test cases. In Test mode, it replays those requests as production-like sandboxes with all dependencies automatically virtualized, comparing responses to detect regressions. This production behavior replay enables continuous validation, migration regression testing, and legacy application testing without code changes. + ## 🌟 Keploy V2 Architecture 🌟 ### 🎯 Goals From d82a5ea860e8726f7de85cff0d4b29ed93ece8dc Mon Sep 17 00:00:00 2001 From: slayerjain Date: Thu, 2 Apr 2026 01:17:56 +0530 Subject: [PATCH 2/3] fix: remove unused FAQSchema component MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit FAQSchema.jsx was never imported anywhere — dead code with no matching visible FAQ content, risking structured-data spam if accidentally used. Co-Authored-By: Claude Opus 4.6 (1M context) Signed-off-by: slayerjain --- src/components/FAQSchema.jsx | 25 ------------------------- 1 file changed, 25 deletions(-) delete mode 100644 src/components/FAQSchema.jsx diff --git a/src/components/FAQSchema.jsx b/src/components/FAQSchema.jsx deleted file mode 100644 index 9cfe4ad7a..000000000 --- a/src/components/FAQSchema.jsx +++ /dev/null @@ -1,25 +0,0 @@ -import React from 'react'; -import Head from '@docusaurus/Head'; - -export default function FAQSchema({ faqs }) { - const schema = { - "@context": "https://schema.org", - "@type": "FAQPage", - "mainEntity": faqs.map(faq => ({ - "@type": "Question", - "name": faq.question, - "acceptedAnswer": { - "@type": "Answer", - "text": faq.answer - } - })) - }; - - return ( - - - - ); -} From 2f145d7e7cd7cd5fd16f9b33b5b7ee4118e4d17a Mon Sep 17 00:00:00 2001 From: slayerjain Date: Thu, 2 Apr 2026 15:12:33 +0530 Subject: [PATCH 3/3] =?UTF-8?q?feat:=20GEO=20improvements=20=E2=80=94=20an?= =?UTF-8?q?swer=20nuggets,=20schema=20upgrade,=20cross-linking,=20sitemap?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add 40-60 word answer nuggets after H2s in what-is-keploy, how-keploy-works, features docs - Rephrase doc headings as questions for AI extraction - Upgrade Product schema to SoftwareApplication with featureList and keywords - Add sameAs entity disambiguation links to Organization schema - Add blog + landing cross-refs to llms.txt - Fix canonicalBase to match actual domain (keploy.io) - Add missing plugin package.json for docusaurus-tailwindcss-loader - Configure sitemap filename Co-Authored-By: Claude Opus 4.6 (1M context) Signed-off-by: slayerjain --- docusaurus.config.js | 54 +++++++++++++++---- .../package.json | 6 +++ static/llms.txt | 5 ++ .../concepts/what-are-keploy-features.md | 25 ++++++--- .../version-3.0.0/concepts/what-is-keploy.md | 4 ++ .../keploy-explained/how-keploy-works.md | 12 +++-- 6 files changed, 85 insertions(+), 21 deletions(-) create mode 100644 plugins/docusaurus-tailwindcss-loader/package.json diff --git a/docusaurus.config.js b/docusaurus.config.js index 7b0d9b0f2..5dd458e24 100644 --- a/docusaurus.config.js +++ b/docusaurus.config.js @@ -35,7 +35,7 @@ module.exports = { minHeadingLevel: 2, maxHeadingLevel: 2, }, - canonicalBase: "https://www.keploy.io/", + canonicalBase: "https://keploy.io/", metadata: [ { description: "Documentation for Keploy Backend Test Generator", @@ -71,15 +71,42 @@ module.exports = { type: "application/ld+json", }, innerHTML: JSON.stringify({ - "@context": "https://schema.org/", - "@type": "Product", - description: - "Keploy - Open source tool that generates integration tests like unit tests with mocks or stubs from API calls.", - keywords: - "API testing, incident replay, network calls, code paths, test scenarios, code coverage, stubs, junit, go-test, live environment, production incidents, open source, regression tests, ai tests", - name: "Keploy", - url: "https://keploy.io/", - logo: "https://keploy.io/docs/img/favicon.png", + "@context": "https://schema.org", + "@type": "SoftwareApplication", + "name": "Keploy", + "description": "Keploy is an open-source, AI-powered testing agent and sandboxing platform that automatically generates test cases, dependency mocks, and production-like sandboxes from real user traffic using eBPF. It helps developers achieve 90% test coverage in minutes with zero code changes.", + "applicationCategory": "DeveloperTool", + "applicationSubCategory": "Test Automation", + "operatingSystem": ["Linux", "macOS", "Windows"], + "license": "https://www.apache.org/licenses/LICENSE-2.0", + "softwareHelp": "https://docs.keploy.io", + "codeRepository": "https://github.com/keploy/keploy", + "downloadUrl": "https://github.com/keploy/keploy/releases", + "isAccessibleForFree": true, + "url": "https://keploy.io", + "featureList": [ + "Automatic test case generation from real user traffic", + "Production-like sandbox environments from captured traffic", + "AI-powered dependency virtualization and mock generation", + "Record and replay testing with eBPF kernel capture", + "AI noise detection for flaky test elimination", + "Legacy application testing without code changes", + "Migration regression testing against production baselines", + "Continuous validation in CI/CD pipelines", + "Multi-language support (Go, Java, TypeScript, Python)" + ], + "keywords": [ + "test automation", "API testing", "API test generation", + "unit testing", "integration testing", "mock generation", + "dependency virtualization", "eBPF-based testing", + "record and replay", "production sandbox" + ], + "programmingLanguage": ["Go", "Java", "TypeScript", "JavaScript", "Python"], + "publisher": { + "@type": "Organization", + "name": "Keploy", + "url": "https://keploy.io" + } }), }, { @@ -93,6 +120,12 @@ module.exports = { name: "Keploy", url: "https://keploy.io/", logo: "https://keploy.io/docs/img/favicon.png", + sameAs: [ + "https://github.com/keploy", + "https://twitter.com/Keployio", + "https://www.linkedin.com/company/keploy", + "https://www.youtube.com/@keploy" + ], }), }, { @@ -356,6 +389,7 @@ module.exports = { //cacheTime: 600 * 1000, // 600 sec - cache purge period changefreq: "weekly", priority: 0.5, + filename: "sitemap.xml", }, }, ], diff --git a/plugins/docusaurus-tailwindcss-loader/package.json b/plugins/docusaurus-tailwindcss-loader/package.json new file mode 100644 index 000000000..5e2cfeea2 --- /dev/null +++ b/plugins/docusaurus-tailwindcss-loader/package.json @@ -0,0 +1,6 @@ +{ + "name": "docusaurus-tailwindcss-loader", + "version": "1.0.0", + "private": true, + "main": "index.js" +} diff --git a/static/llms.txt b/static/llms.txt index 139948dc0..e412a6a44 100644 --- a/static/llms.txt +++ b/static/llms.txt @@ -36,3 +36,8 @@ - [Unit Testing FAQ](https://keploy.io/docs/keploy-explained/unit-testing-faq/): Auto-generated unit tests, mock generation, coverage - [API Testing FAQ](https://keploy.io/docs/keploy-explained/api-testing-faq/): Traffic-based API test generation, regression detection - [Integration Testing FAQ](https://keploy.io/docs/keploy-explained/integration-testing-faq/): Dependency virtualization, production sandboxes + +## Related Resources +- [Keploy Homepage](https://keploy.io): Product overview, pricing, and enterprise information +- [Keploy Blog](https://keploy.io/blog): Technical articles on API testing, eBPF, test automation, and developer productivity +- [Keploy Cloud](https://app.keploy.io): Managed Keploy cloud platform diff --git a/versioned_docs/version-3.0.0/concepts/what-are-keploy-features.md b/versioned_docs/version-3.0.0/concepts/what-are-keploy-features.md index a68da419e..c3c5cdee3 100644 --- a/versioned_docs/version-3.0.0/concepts/what-are-keploy-features.md +++ b/versioned_docs/version-3.0.0/concepts/what-are-keploy-features.md @@ -18,15 +18,16 @@ keywords: - mock mutations --- -## Key Features +## What are Keploy's key features? -Keploy is built for a wide variety of use-cases, however, to kick things off, let's dive into some key features that -make Keploy stand out from the rest of the testing platforms out there. +Keploy provides combined test coverage reporting in CI/CD pipelines, records complex distributed API flows as replayable test cases, automatically mocks all external dependencies including databases and third-party services, detects and filters noisy fields like timestamps from assertions, and supports multiple languages through code-less eBPF-based instrumentation that requires zero application changes. -## 🧩 Combined Test Coverage in CI/CD: +## 🧩 How does Keploy provide combined test coverage in CI/CD? #### Run Tests with Mocks Anywhere You Like +Keploy integrates natively with unit-testing frameworks such as go-test, jUnit, jest, and pyTest to report combined test coverage from both recorded API tests and existing unit tests. Tests can run locally on the CLI, inside CI pipelines, or across Kubernetes clusters, giving teams a unified coverage metric without maintaining separate test infrastructure. + Keploy has [native integrations](/concepts/general-glossary.md#4-interoperability) with your unit-testing libraries like `go-test`, `jUnit`, `jest`, `pyTest`. Keploy gives combined test-coverage and can also be integrated in existing CI pipelines easily within `go-test`, `jUnit`, `jest`, `pyTest` workflows. @@ -36,10 +37,12 @@ pipelines easily within `go-test`, `jUnit`, `jest`, `pyTest` workflows. 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! 🌍 -## 📽️ Works for Complex API Flows +## 📽️ How does Keploy handle complex API flows? #### Can easily record complex API flows and replay them as tests and stubs. +Keploy records all API calls and their downstream network interactions, including database queries, cache lookups, and third-party service calls, then stores them as replayable YAML test cases with auto-generated dependency mocks. This allows teams to reproduce multi-service distributed flows locally or in CI without connecting to live external services. + With Keploy, you can effortlessly record and replay intricate, distributed API flows as mocks and stubs. It's like having a time machine for your tests! ⏳ @@ -64,23 +67,29 @@ Multiple Reads after write operations can be replicated automatically too. 🔄 [//]: # 'API Tools' -## ♻️ Multi-Purpose Mocks +## ♻️ What are Keploy's multi-purpose mocks? #### Re-Use Mocks for Testing Servers +Keploy-generated dependency mocks serve multiple testing purposes beyond regression tests. The same recorded mocks can be reused for chaos testing, end-to-end testing, integration testing, and API contract testing, eliminating the need to create and maintain separate mock data sets for each testing strategy. + Keploy generated dependency mocks can also be used as test case for the server. These tests can be used for use-cases like chaos testing, e2e testing, integration testing, api and regression testing. 🌟 -## 🌐 Code-less EBPF Instrumentation +## 🌐 How does Keploy achieve code-less instrumentation? #### Network Layer Integration makes it Light-Weight +Keploy uses eBPF (extended Berkeley Packet Filter) to attach hooks at the Linux kernel's network layer, intercepting system calls for incoming and outgoing connections. This kernel-level approach requires zero application code changes, works with any programming language or framework, and adds minimal performance overhead compared to user-space instrumentation. + Keploy uses EBPF like a secret sauce to make integration code-less, language agnostic, and oh-so-lightweight. 🍲 -## 🔍 Accurate Noise Detection +## 🔍 How does Keploy detect and handle noise in tests? #### Eliminates random fields for Assertion +Keploy automatically identifies noisy fields in API responses, such as timestamps, UUIDs, and random values, by comparing multiple replays of the same request. Fields that change between runs are marked as noise and excluded from assertions, ensuring that generated test cases remain stable and do not produce false-positive failures. + Keploy identifies [noisy fields](/concepts/general-glossary.md#3-noisy-field) in the responses accurately like ( timestamps, random values) to ensure high quality tests. diff --git a/versioned_docs/version-3.0.0/concepts/what-is-keploy.md b/versioned_docs/version-3.0.0/concepts/what-is-keploy.md index 3c2f68212..b7dc137b9 100644 --- a/versioned_docs/version-3.0.0/concepts/what-is-keploy.md +++ b/versioned_docs/version-3.0.0/concepts/what-is-keploy.md @@ -19,6 +19,10 @@ keywords: - AI Generated Tests --- +## What is Keploy? + +Keploy is an open-source, AI-powered testing agent that generates backend API test cases and dependency mocks by recording real application network calls. Using eBPF kernel-level hooks, Keploy captures traffic without code changes, achieves up to 90% test coverage in minutes, and replays recorded interactions as automated regression tests with built-in stubs for databases, caches, and third-party services. + Keploy creates backend **API tests with built-in-mocks** or stubs **by recording your application network calls** making your testing process not only faster than unit tests but also incredibly efficient. diff --git a/versioned_docs/version-3.0.0/keploy-explained/how-keploy-works.md b/versioned_docs/version-3.0.0/keploy-explained/how-keploy-works.md index 16cc5df52..5235af0e9 100644 --- a/versioned_docs/version-3.0.0/keploy-explained/how-keploy-works.md +++ b/versioned_docs/version-3.0.0/keploy-explained/how-keploy-works.md @@ -10,7 +10,9 @@ tags: - record-test-case --- -## 🌟 Keploy V2 Architecture 🌟 +## How does Keploy work? + +Keploy uses eBPF hooks at the Linux kernel level to intercept incoming and outgoing network traffic from an application without requiring any code changes. In record mode, it captures API calls and their downstream dependency interactions, storing them as YAML test cases and stubs. In test mode, Keploy replays those recorded requests and auto-mocks all external dependencies, enabling deterministic regression testing. ### 🎯 Goals @@ -20,7 +22,9 @@ tags: - 🔒 **TLS Support:** Secure connections in HTTPS or databases are supported. - 🔄 **Request Matching:** Mocking responses during testing by matching requests. -## 🏗 High-level architecture +## What is Keploy's high-level architecture? + +Keploy's architecture consists of three core components: an eBPF hooks loader that intercepts ingress and egress network traffic at the kernel level, a transparent network proxy that records or mocks outgoing calls to databases and external services, and an API server that manages test execution and resource lifecycle. This design enables zero-code instrumentation across any language or framework. Keploy uses eBPF to instrument applications without code changes. Key components include: @@ -49,7 +53,9 @@ The Network Proxy acts as a transparent proxy for recording or mocking outgoing The API server manages commands for start/stop and resource management (e.g., testicles, stubs). It's evolving to enable full agent mode, beyond just CLI. -## 🧪 Example +## How does Keploy record and replay tests? + +Keploy operates in two modes. In record mode, eBPF hooks capture all incoming HTTP requests and redirect outgoing TCP/UDP traffic through a proxy that saves interactions as YAML files. In test mode, Keploy reads those YAML files, replays the recorded HTTP requests against the application, and mocks all outgoing dependency calls to prevent side effects. Consider an application server serving HTTP APIs for clients like web/mobile apps, postman, or curl, and depending on a database and another API.