Karate Framework for Simplified API Test Automation

API testing is a crucial component of modern software development, as it ensures that backend services and integrations function correctly, reliably, and securely. With the increasing complexity of distributed systems and microservices, validating API responses, performance, and behavior has become more important than ever. The Karate framework simplifies this process by offering a powerful and user-friendly platform that brings together API testing, automation, and assertions in a single framework. In this tutorial, we’ll walk you through how to set up and use Karate for API testing step by step. From installation to writing and executing your first test case, this guide is designed to help you get started with confidence. Whether you’re a beginner exploring API automation or an experienced tester looking for a simpler and more efficient framework, Karate provides the tools you need to build robust and maintainable API test automation.

What is the Karate Framework?

Karate is an open-source testing framework designed for API testing, API automation, and even UI testing. Unlike traditional tools that require extensive coding or complex scripting, Karate simplifies test creation by using a domain-specific language (DSL) based on Cucumber’s Gherkin syntax. This makes it easy for both developers and non-technical testers to write and execute test cases effortlessly.

With Karate, you can define API tests in plain-text (.feature) files, reducing the learning curve while ensuring readability and maintainability. It offers built-in assertions, data-driven testing, and seamless integration with CI/CD pipelines, making it a powerful choice for teams looking to streamline their automation efforts with minimal setup.

Prerequisites

Before we dive in, ensure you have the following:

• Java Development Kit (JDK): Version 8 or higher installed (Karate runs on Java).
• Maven: A build tool to manage dependencies (we’ll use it in this tutorial).
• An IDE: IntelliJ IDEA, Eclipse, or VS Code.
• A sample API: We’ll use the free Reqres for testing.

Let’s get started!

Step 1: Set Up Your Project

1. Create a New Maven Project

• If you’re using an IDE like IntelliJ, select “New Project” > “Maven” and click “Next.”
• Set the GroupId (e.g., org.example) and ArtifactId (e.g., KarateTutorial).

2. Configure the pom.xml File

Open your pom.xml and add the Karate dependency. Here’s a basic setup:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>org.example</groupId>
 <artifactId>KarateTutorial</artifactId>
 <version>1.0-SNAPSHOT</version>
 <name>Archetype - KarateTutorial</name>
 <url>http://maven.apache.org</url>




<properties>
 <maven.compiler.source>1.8</maven.compiler.source>
 <maven.compiler.target>1.8</maven.compiler.target>
 <karate.version>1.4.1</karate.version>
</properties>


<dependencies>
 <dependency>
   <groupId>com.intuit.karate</groupId>
   <artifactId>karate-junit5</artifactId>
   <version>${karate.version}</version>
   <scope>test</scope>
 </dependency>
</dependencies>


<build>
 <testResources>
   <testResource>
     <directory>src/test/java</directory>
     <includes>
       <include>**/*.feature</include>
     </includes>
   </testResource>
 </testResources>
 <plugins>
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-surefire-plugin</artifactId>
     <version>3.0.0-M5</version>
   </plugin>
 </plugins>
</build>
</project>

• This setup includes Karate with JUnit 5 integration and ensures that .feature files are recognized as test resources.

Sync the Project

• In your IDE, click “Reload Project” (Maven) to download the dependencies. If you’re using the command line, run mvn clean install.

Step 2: Create Your First Karate Test

1. Set Up the Directory Structure

• Inside src/test/java, create a folder called tests (e.g., src/test/java/tests).
• This is where we’ll store our .feature files.

2. Write a Simple Test

• Create a file named api_test.feature inside the tests folder.
• Add the following content:

Feature: Testing Reqres API with Karate


 Background:
   * url 'https://reqres.in'


 Scenario: Get a list of users
   Given path '/api/users?page=1'
   When method GET
   Then status 200
   And match response.page == 1
   And match response.per_page == 6
   And match response.total == 12
   And match response.total_pages == 2

Explanation:

• Feature: Describes the purpose of the test file.
• Scenario: A single test case.
• Given url: Sets the API endpoint.
• When method GET: Sends a GET request.
• Then status 200: Verifies the response status is 200 (OK).
• And match response.page == 1: Checks that the page value is equal to 1.

Step 3: Run the Test

1. Create a Test Runner

• In src/test/java/tests, create a Java file named ApiTestRunner.java:

package tests;


import com.intuit.karate.junit5.Karate;


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

• This runner tells Karate to execute the api_test.feature file.

Before Execution make sure the test folder looks like this.

2. Execute the Test

• Right-click ApiTestRunner.java and select “Run.”

You should see a report indicating the test passed, along with logs of the request and response.

Step 4: Expand Your Test Cases

Let’s add more scenarios to test different API functionalities.

1. Update api_test.feature

Replace the content with:

Feature: Testing Reqres API with Karate


 Background:

   * url 'https://reqres.in'


 Scenario: Get a list of users

   Given path '/api/users?page=1'

   When method GET

   Then status 200

   And match response.page == 1

   And match response.per_page == 6

   And match response.total == 12

   And match response.total_pages == 2


 Scenario: Get a single user by ID

   Given path '/api/users/2'

   When method GET

   Then status 200

   And match response.data.id == 2

   And match response.data.email == "[email protected]"

   And match response.data.first_name == "Janet"

   And match response.data.last_name == "Weaver"


 Scenario: Create a new post

   Given path 'api/users'

   And request {"name": "morpheus","job": "leader"}

   When method POST

   Then status 201

   And match response.name == "morpheus"

   And match response.job == "leader"

Explanation:

• Background: Defines a common setup (base URL) for all scenarios.
• First scenario: Tests GET request for a list of users.
• Second scenario: Tests GET request for a specific user.
• Third scenario: Tests POST request to create a resource.

Run the Updated Tests

• Use the same ApiTestRunner.java to execute the tests. You’ll see results for all three scenarios.

Step 5: Generate Reports

Karate automatically generates HTML reports.

1. Find the Report

• After running tests, check target/surefire-reports/karate-summary.html in your project folder.

• Open it in a browser to see a detailed summary of your test results.

Conclusion

Karate is a powerful yet simple framework that makes API automation accessible for both beginners and experienced testers. In this tutorial, we covered the essentials of API testing with Karate, including setting up a project, writing test cases, running tests, and generating reports. Unlike traditional API testing tools, Karate’s Gherkin-based syntax, built-in assertions, parallel execution, and seamless CI/CD integration allow teams to automate tests efficiently without extensive coding. Its data-driven testing and cross-functional capabilities make it an ideal choice for modern API automation. At Codoid, we specialize in API testing, UI automation, performance testing, and test automation consulting, helping businesses streamline their testing processes using tools like Karate, Selenium, and Cypress. Looking to optimize your API automation strategy? Codoid provides expert solutions to ensure seamless software quality—reach out to us today!

Frequently Asked Questions