How to Read Data From Json File in Karate Framework: A Guide

Disclosure: As an Amazon Associate, I earn from qualifying purchases. This post may contain affiliate links, which means I may receive a small commission at no extra cost to you.

Hey there! If you’re working with Karate and need to grab data from JSON files, you’re in the right place. Reading data from JSON is a common task in API testing and automation. It allows you to use external data for your tests, making them more flexible and easier to maintain. This guide will walk you through the process step-by-step, covering everything from the basics to some more advanced techniques.

We’ll explore how to load JSON files, access data within them, and use that data in your Karate tests. I’ll provide clear examples and practical tips to help you get up and running quickly. Whether you’re a beginner or have some experience with Karate, this guide will provide you with the knowledge you need to effectively handle JSON data.

Let’s get started and see how easy it is to integrate JSON files into your Karate tests and make them more powerful and adaptable! I’ll break everything down so you can easily follow along.

Understanding Json and Why It Matters in Karate

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It’s easy for humans to read and write, and easy for machines to parse and generate. In the context of Karate, JSON is incredibly useful because it allows you to:

Separate data from your test logic: This makes your tests more organized and easier to update.
Use external data sources: You can load data from various sources (files, databases, APIs) into your tests.
Parameterize your tests: You can run the same test with different sets of data.

Think of JSON as a way to store data in a structured format, similar to a dictionary or a map. It consists of key-value pairs, where the keys are strings and the values can be strings, numbers, booleans, arrays, or even other JSON objects. This flexibility makes JSON ideal for representing complex data structures.

Before diving into Karate, let’s look at a simple JSON example:

{
  "name": "John Doe",
  "age": 30,
  "isEmployed": true,
  "address": {
    "street": "123 Main St",
    "city": "Anytown"
  },
  "hobbies": ["reading", "coding"]
}

In this example, we have a JSON object with several key-value pairs. The “name” key has a string value, “age” has a number, “isEmployed” has a boolean, “address” has another JSON object, and “hobbies” has an array of strings. Understanding this structure is crucial for accessing data in your Karate tests.

Setting Up Your Karate Project

Before you can read data from a JSON file, you’ll need a Karate project set up. If you already have one, feel free to skip this section. If not, here’s a quick guide to get you started:

Create a new Maven project: You can do this using your IDE (like IntelliJ IDEA or Eclipse) or from the command line using the Maven archetype.
Add the Karate dependency: In your `pom.xml` file, add the following dependency within the `` section:


    com.intuit.karate
    karate-junit5
    1.4.1 
    test

Make sure to replace `1.4.1` with the latest version of Karate. You can find the latest version on the Maven Central Repository.

Create a feature file: Create a directory structure for your feature files (e.g., `src/test/java/com/example/karate`). Inside this directory, create a new file with a `.feature` extension (e.g., `my_test.feature`).
Create a JSON file: Create a directory (e.g., `src/test/resources/data`). Inside this directory, create your JSON file (e.g., `user_data.json`). This is where you’ll store the data you want to read.
Write a simple test: In your `.feature` file, write a simple test to get started.

Here’s a basic example of a `my_test.feature` file:

Feature: Read Data from JSON File

  Scenario: Read user data from JSON
    Given url 'https://reqres.in'
    And path '/api/users/2'
    When method GET
    Then status 200
    And print response

And here’s an example of a `user_data.json` file:

{
  "id": 2,
  "email": "[email protected]",
  "first_name": "Janet",
  "last_name": "Weaver",
  "avatar": "https://reqres.in/img/faces/2-image.jpg"
}

With these files in place, you’re ready to start reading data from your JSON file within your Karate tests.

Reading a Json File in Karate

Karate provides several ways to read data from a JSON file. The most common and straightforward method is using the `read()` keyword. Here’s how it works:

Use the `read()` keyword: Inside your Karate feature file, you use the `read()` keyword to load the JSON file into a variable.
Specify the file path: The `read()` keyword takes the path to your JSON file as an argument. The path is relative to the `src/test/resources` directory.
Access the data: Once the JSON file is loaded, you can access the data using the variable you assigned.

Let’s look at a practical example. Suppose you have a JSON file named `user_data.json` located in the `src/test/resources/data` directory. Here’s how you would read this file in your Karate test: (See Also: How To Unlock Chao Karate )

Feature: Read Data from JSON File

  Scenario: Read user data from JSON
    * def userData = read('classpath:data/user_data.json')
    * print userData
    Given url 'https://reqres.in'
    And path '/api/users/2'
    When method GET
    Then status 200
    And match response.data == userData

In this example, the `read(‘classpath:data/user_data.json’)` line reads the `user_data.json` file and stores the contents in the `userData` variable. The `classpath:` prefix tells Karate to look for the file in the classpath, which includes the `src/test/resources` directory.

The `* print userData` line prints the contents of the `userData` variable to the console, allowing you to verify that the file was read correctly. The `match response.data == userData` line shows how to compare the response data to the data read from the JSON file. Note that in a more complete example, we would need to parse the response to match the structure of our JSON file.

Important considerations:

File path: Always use the correct relative path to your JSON file, starting from the `src/test/resources` directory.
Error handling: If the file is not found or if there’s an error reading the file, Karate will throw an error. Make sure your file path is correct.
Data type: The data read from the JSON file will be automatically converted to a JavaScript object, which you can then access in your Karate steps.

Accessing Data Within the Json Object

Once you’ve read the JSON file into a variable, the next step is to access the individual data elements. Karate provides a straightforward way to do this using dot notation or bracket notation, similar to how you would access properties of a JavaScript object.

Dot notation: Use the dot (`.`) to access nested elements. For example, if your JSON contains `{“address”: {“city”: “Anytown”}}`, you can access the city using `userData.address.city`.
Bracket notation: Use bracket notation (`[]`) to access elements with spaces or special characters in their keys. For example, if your JSON contains `{“first name”: “John”}`, you would access the first name using `userData[‘first name’]`.

Let’s illustrate with the `user_data.json` example from the previous section. Recall that the content of the file is:

{
  "id": 2,
  "email": "[email protected]",
  "first_name": "Janet",
  "last_name": "Weaver",
  "avatar": "https://reqres.in/img/faces/2-image.jpg"
}

Here’s how you can access the different data elements in your Karate test:

Feature: Accessing JSON Data

  Scenario: Access user data elements
    * def userData = read('classpath:data/user_data.json')
    * print 'User ID:', userData.id
    * print 'Email:', userData.email
    * print 'First Name:', userData.first_name
    * print 'Last Name:', userData.last_name
    * print 'Avatar URL:', userData.avatar

In this example, we use dot notation to access the `id`, `email`, `first_name`, `last_name`, and `avatar` elements of the `userData` object. The `print` statements will display the values of these elements in the console, allowing you to verify that you’re accessing the data correctly.

Key takeaways:

Dot notation is generally preferred for its readability, unless your keys contain spaces or special characters.
Use bracket notation when dealing with keys that have spaces or special characters.
Verify your data access: Always use `print` statements to check that you are accessing the correct data elements, especially when dealing with complex JSON structures.

Using Data From Json in Your Tests

The real power of reading data from JSON files comes when you use that data in your tests. This allows you to parameterize your tests and run them with different sets of data, making your tests more flexible and robust. You can use the data you read from the JSON file in various ways, such as:

Setting request parameters: Use the data to populate request bodies or query parameters.
Verifying response data: Compare the response data with the data from your JSON file.
Building dynamic URLs: Construct URLs based on the data in your JSON file.

Let’s look at some examples of how to use data from a JSON file in your Karate tests:

Setting request parameters:

Feature: Using JSON Data for Request

  Scenario: Create a new user
    * def newUser = read('classpath:data/new_user.json')
    Given url 'https://reqres.in/api/users'
    And request newUser
    When method POST
    Then status 201
    And match response.name == 'morpheus'
    And match response.job == 'leader'

In this example, we read a JSON file named `new_user.json` which might contain the details of a new user. We then use this data as the request body for a POST request. The `request newUser` line sets the entire JSON object as the request body. The response is then matched against expected values.

Verifying response data:

Feature: Verifying Response with JSON Data

  Scenario: Verify user data
    * def expectedUser = read('classpath:data/user_data.json')
    Given url 'https://reqres.in'
    And path '/api/users/2'
    When method GET
    Then status 200
    And match response.data == expectedUser

In this example, we read `user_data.json` and store it in `expectedUser`. We then make a GET request to retrieve user data. The `match response.data == expectedUser` line compares the `response.data` with the data we read from the JSON file, ensuring that the response data matches our expectations.

Building dynamic URLs:

Feature: Building Dynamic URLs

  Scenario: Get user by ID
    * def userId = read('classpath:data/user_id.json').id
    Given url 'https://reqres.in'
    And path '/api/users/' + userId
    When method GET
    Then status 200
    And print response

In this example, we read a JSON file (`user_id.json`) that contains a user ID. We then use that ID to construct a dynamic URL for a GET request. This demonstrates how you can use data from JSON files to make your tests more flexible and adaptable to different scenarios. (See Also: Do Koreans Do Karate )

Best practices:

Structure your JSON files logically: Organize your JSON files in a way that makes sense for your tests. For example, you might have separate files for different types of data (e.g., user data, product data, etc.).
Use variables for reusability: Store data from JSON files in variables and reuse those variables throughout your tests.
Keep your JSON files simple: Avoid overly complex JSON structures. If you need complex data, consider breaking it down into smaller, more manageable JSON files.

Working with Arrays and Nested Objects

JSON files often contain arrays and nested objects. Accessing data within these structures requires a slightly different approach, but Karate makes it easy. Let’s explore how to work with arrays and nested objects:

Working with arrays:

Arrays in JSON are ordered lists of values. You can access elements in an array using their index (starting from 0). For example, if your JSON contains `{“hobbies”: [“reading”, “coding”]}`, you can access the first hobby using `userData.hobbies[0]` and the second hobby using `userData.hobbies[1]`.

Feature: Working with Arrays

  Scenario: Access array elements
    * def userData = read('classpath:data/user_data_with_hobbies.json')
    * print 'First hobby:', userData.hobbies[0]
    * print 'Second hobby:', userData.hobbies[1]

In this example, we read a JSON file (e.g., `user_data_with_hobbies.json`) that contains an array of hobbies. We then access the elements of the array using their indices. The `print` statements will display the first and second hobbies.

Working with nested objects:

Nested objects are objects within objects. You can access elements in nested objects using dot notation. For example, if your JSON contains `{“address”: {“city”: “Anytown”}}`, you can access the city using `userData.address.city`.

Feature: Working with Nested Objects

  Scenario: Access nested object elements
    * def userData = read('classpath:data/user_data_with_address.json')
    * print 'City:', userData.address.city
    * print 'Street:', userData.address.street

In this example, we read a JSON file (e.g., `user_data_with_address.json`) that contains a nested `address` object. We then access the `city` and `street` elements using dot notation.

Tips for working with complex structures:

Use `print` statements extensively: Print the entire JSON object or specific parts of it to understand its structure and verify that you’re accessing the data correctly.
Break down complex structures: If your JSON file has a very complex structure, consider breaking it down into smaller, more manageable parts.
Use variables for intermediate values: Store intermediate values in variables to simplify your code and make it more readable.

Using Json Files with Data-Driven Testing

One of the most powerful features of Karate is its ability to support data-driven testing. This means you can run the same test multiple times with different sets of data, often sourced from JSON files. This significantly reduces code duplication and allows you to test various scenarios efficiently.

Using `examples` block:

The `examples` block within a scenario is the simplest way to perform data-driven testing. You define a table of data, and Karate runs the scenario for each row in the table.

Feature: Data-Driven Testing with Examples

  Scenario: Create a new user
    * def newUser = read('classpath:data/new_user_template.json')
    Given url 'https://reqres.in/api/users'
    And request newUser
    When method POST
    Then status 201
    Examples:
      | name      | job       |
      | "John"    | "leader"  |
      | "Jane"    | "developer" |
      | "David"   | "tester"  |

In this example, the scenario will run three times, once for each row in the `examples` table. The values in the table can be used to modify the `newUser` request. This example is simplified for illustrative purposes. We will look at a more complex example using JSON data.

Using a list of JSON objects:

You can also use a list of JSON objects to drive your tests. This is particularly useful when you have a large dataset stored in a JSON file.

Feature: Data-Driven Testing with JSON

  Scenario: Create a new user
    * def users = read('classpath:data/users.json')
    * configure dataDriven = users
    Given url 'https://reqres.in/api/users'
    And request {
      "name": "#(name)",
      "job": "#(job)"
    }
    When method POST
    Then status 201
    And match response.name == '#(name)'
    And match response.job == '#(job)'

In this example, we read a JSON file (`users.json`) that contains an array of user objects. The `configure dataDriven = users` line tells Karate to use the `users` array for data-driven testing. Inside the `request` section, the `#(name)` and `#(job)` expressions are used to access the data from the current user object. The scenario will run for each user object in the `users` array.

Here’s what `users.json` might look like: (See Also: How To Block Punches In Karate )

[
  {
    "name": "John",
    "job": "leader"
  },
  {
    "name": "Jane",
    "job": "developer"
  },
  {
    "name": "David",
    "job": "tester"
  }
]

Key considerations for data-driven testing:

Structure your data: Organize your JSON data in a way that makes it easy to use with your tests.
Use variables effectively: Use variables to access data from the JSON file and use them in your requests and assertions.
Test coverage: Ensure that your data covers all the scenarios you want to test.

Advanced Techniques and Tips

Let’s explore some advanced techniques and tips to help you become even more proficient at reading data from JSON files in Karate:

Using JSONPath:

JSONPath is a powerful query language that allows you to extract data from JSON documents based on a path expression. Karate has built-in support for JSONPath, making it easy to extract specific elements from complex JSON structures.

Feature: Using JSONPath

  Scenario: Extract data using JSONPath
    * def userData = read('classpath:data/user_data.json')
    * def email = $userData.email  // Using JSONPath to get email
    * print 'Email:', email
    * def first_name = $userData.first_name
    * print 'First Name:', first_name

In this example, we use JSONPath expressions (`$userData.email`) to extract the email from the `userData` object. The `$` prefix indicates that we are using JSONPath. This is a very efficient and flexible way to access specific data elements, especially when dealing with complex JSON structures.

Combining JSON files:

You can combine data from multiple JSON files to create more complex data structures for your tests. This can be useful when you have data spread across different files.

Feature: Combining JSON Files

  Scenario: Combine data from multiple JSON files
    * def userDetails = read('classpath:data/user_details.json')
    * def userAddress = read('classpath:data/user_address.json')
    * def combinedUserData = { ...userDetails, address: userAddress }
    * print combinedUserData

In this example, we read two JSON files (`user_details.json` and `user_address.json`). Then, we combine the data from these files into a new object called `combinedUserData`. The `…userDetails` uses the spread operator to include all the properties from `userDetails` in the `combinedUserData`. We then add the `address` property from `userAddress`. This allows you to create a unified data structure from multiple sources.

Using variables for file paths:

Instead of hardcoding the file paths in your `read()` calls, you can use variables. This makes your tests more flexible and easier to maintain, especially if the file paths change.

Feature: Using Variables for File Paths

  Scenario: Read data using a variable for the file path
    * def dataFilePath = 'classpath:data/user_data.json'
    * def userData = read(dataFilePath)
    * print userData

In this example, we define a variable `dataFilePath` and assign the file path to it. We then use this variable in the `read()` call. If the file path changes, you only need to update the `dataFilePath` variable, rather than modifying multiple `read()` calls throughout your tests.

Error handling and validation:

While the `read()` function handles basic file reading, you might want to add error handling and validation to ensure your tests are robust. For instance, you could check if a file exists before attempting to read it.

Feature: Error Handling

  Scenario: Check if the file exists before reading
    * def filePath = 'classpath:data/user_data.json'
    * def fileExists = karate.readFile(filePath) != null
    * if (fileExists) {
      * def userData = read(filePath)
      * print userData
    } else {
      * print 'File not found: ' + filePath
      * fail 'User data file not found!'
    }

In this example, we use `karate.readFile()` to check if the file exists. If the file exists, we read the data. Otherwise, we print an error message and fail the test. This helps prevent unexpected errors due to missing files.

Using external libraries:

Karate allows you to use external Java libraries. This can be useful if you need to perform more complex operations on your JSON data, such as data transformations or validation using third-party libraries. However, for most common use cases, the built-in features of Karate are sufficient.

These advanced techniques provide you with the tools to handle more complex scenarios and make your Karate tests even more powerful and maintainable. Remember to practice and experiment with these techniques to find the best approach for your specific needs.

🔥 Read More:

Verdict

You’ve now learned the essential skills for reading data from JSON files in the Karate framework! We’ve covered the basics of JSON, how to read files using `read()`, access data using dot and bracket notation, use this data in your tests, and perform data-driven testing. Remember to apply these techniques consistently. Also, explore advanced topics such as JSONPath and combining JSON files. With practice, you can create robust, flexible, and maintainable Karate tests that effectively leverage JSON data. Happy testing!

Recommended Karate Belts & Teaching

Bestseller No. 1