Khushi Singla

Posted on May 29

A Developer’s Guide to API Testing with Karate Framework

#karate #apitesting #tutorial #learning

In the world of modern software development, API testing is essential for validating backend services—ensuring they respond correctly, behave as expected, and remain reliable over time. Among the many tools available for API automation, Karate Framework stands out for its elegant syntax, powerful capabilities, and developer-friendly approach.

This guide walks you through what Karate is, why it's a compelling choice for API testing, how to write your first test, and how to integrate Karate into your CI/CD pipeline for continuous quality assurance.

What is Karate Framework?

Karate is an open-source test automation tool designed specifically for API testing. Built on top of the Cucumber JVM, it enables developers and testers to write expressive, readable tests using simple Gherkin syntax inside .feature files—no Java code required to get started.

Key Features of Karate

✅ Supports testing of REST, SOAP, GraphQL, and HTTP APIs
✅ Built-in assertions for JSON and XML payloads
✅ Data-driven testing using Scenario Outline
✅ Supports reusable test logic via call and external files
✅ Includes tools for API mocking and performance testing
✅ Parallel test execution out of the box
✅ Native support for reporting and logging
✅ Seamless integration with Maven, Gradle, and CI/CD pipelines

Why Choose Karate for API Testing?

Simplicity: Write clean and concise tests without boilerplate code.
Unified Testing Tool: Combine functional, mocking, and performance testing in one framework.
Data-Driven: Define test scenarios once and run them with multiple datasets.
Reusability: Easily modularize tests using call for maintainable test suites.
Active Community: Strong documentation and support from the open-source community.

Setting Up Karate Framework

1. Create a Maven Project

If you're using Maven, start by adding the Karate dependency to your pom.xml:

<dependency>
    <groupId>com.intuit.karate</groupId>
    <artifactId>karate-junit5</artifactId>
    <version>1.3.1</version>
    <scope>test</scope>
</dependency>

Alternatively, you can use Gradle—Karate supports both build tools.

2. Create the Directory Structure

src
└── test
    └── java
        └── api
            └── test.feature

Writing Your First Karate Test

Let’s start with a simple GET request to the GitHub API.

File: src/test/java/api/test.feature

Feature: Test GitHub API

  Scenario: Get user details
    Given url 'https://api.github.com/users/octocat'
    When method get
    Then status 200
    And match response.login == 'octocat'
    And match response.id == 583231

What’s Happening Here?

Given url sets the target API endpoint.
When method get performs a GET request.
Then status checks for HTTP 200 OK.
match asserts the content of the response.

Running Karate Tests

Create a Java test runner to execute your .feature files using JUnit 5:

import com.intuit.karate.junit5.Karate;

class ApiTestRunner {
    @Karate.Test
    Karate testAll() {
        return Karate.run("api/test").relativeTo(getClass());
    }
}

Run this test just like any JUnit test—either from your IDE or within a CI environment.

Advanced Examples

1. Data-Driven Testing

You can use Scenario Outline and an Examples table to test multiple variations of a scenario:

Feature: Test multiple GitHub users

  Scenario Outline: Validate GitHub users exist
    Given url 'https://api.github.com/users/<username>'
    When method get
    Then status 200
    And match response.login == '<username>'

  Examples:
    | username |
    | octocat  |
    | defunkt  |
    | mojombo  |

2. Sending POST Request with Headers and Params

Here’s how to test a POST endpoint with headers, query parameters, and a request body:

Feature: Create resource on mock API

  Scenario: Create a post with query params and headers
    Given url 'https://jsonplaceholder.typicode.com/posts'
    And param draft = true
    And header Authorization = 'Bearer dummyToken123'
    And header Content-Type = 'application/json'
    And request
      """
      {
        "title": "foo",
        "body": "bar",
        "userId": 1
      }
      """
    When method post
    Then status 201
    And match response.title == 'foo'
    And match response.body == 'bar'
    And match response.userId == 1

Karate in CI/CD Pipelines

Karate tests are easy to integrate into your build pipelines using Maven or Gradle. For example, a basic Maven command to run all tests:

mvn test

You can plug this into your CI workflows (GitHub Actions, Jenkins, GitLab CI, etc.) to ensure automated API validation as part of every build.

👉 Check out my next blog: Integrating Karate with Jenkins for CI/CD for a step-by-step guide on setting up Karate in a Jenkins pipeline.

Conclusion

Karate makes API testing both accessible and powerful. Whether you're validating REST endpoints, mocking responses, or setting up performance tests, Karate provides a unified solution that fits seamlessly into modern development workflows.

If you're just getting started with API automation, Karate’s readable syntax and robust features make it one of the best tools to learn and use.

DEV Community