Mastering Test Automation with Karate Framework. (2024)

In today’s fast-paced software development world, test automation is no longer a luxury but a necessity. Agile teams rely on efficient testing tools that are not only powerful but also easy to use. The Karate framework is one such tool that has gained popularity for its simplicity and effectiveness. In this blog post, we’ll explore the Karate framework, its key features, and provide code snippets to get you started.

Karate framework (tools) is an open-source test automation framework that provides combined unified package of API and UI testing . Its power lies in its ability to create expressive and readable tests using the Gherkin language, popular in Behavior-Driven Development (BDD). Let’s delve into its key features:

See Also

Karate API Testing I Karate Labs

Karate seamlessly integrates with BDD practices, allowing teams to write test scenarios in a natural language that can be understood by developers, testers, and business stakeholders alike. This fosters collaboration and transparency.

Karate bridges the gap between API and UI testing, enabling end-to-end testing scenarios. With a single framework, you can test your application from the backend to the user interface, streamlining your testing process.

Karate is a self-contained framework, eliminating the need to integrate with external tools. It comes with a built-in HTTP client and browser automation tool, reducing setup and maintenance efforts.

Karate supports JavaScript expressions, making it highly customizable and extensible according to your specific testing requirements.

With Karate, you can easily perform data-driven testing by parameterizing your tests, allowing for versatility and efficiency.

Karate supports cross-browser testing through WebDriver, providing a robust solution for UI automation.

Karate’s unified approach to API and UI testing accelerates test development and execution, crucial for agile development cycles.

The natural language, BDD approach of Karate encourages collaboration and understanding among team members.

Karate’s self-contained nature reduces the need for external dependencies, resulting in lower maintenance overhead.

With native JavaScript support, you can customize your tests to handle complex scenarios efficiently.

Karate is open-source, making it a cost-effective choice for teams and organizations of all sizes.

1.Installation: Start by downloading and installing Karate. Comprehensive installation instructions are available in the official documentation.

2.Writing Tests: Create test scenarios using the Gherkin language, providing readability and expressiveness.

3.Execution: Run your tests and analyze the results. Karate offers detailed reports and integrates with popular CI/CD tools.

If you are a Java Progarmmer— Karate requires at least JDK 11.0 and then either Maven , Gradle(project management tools) or a Java IDE that embeds either to be installed in your machine. Note that Karate framework works fine on OpenJDK as well.

If you are beginners to programming or testing-automation, the official IntelliJ plugin(driver) is recommended.

If you do not want to use Java or open jdk, the Karate extension for Visual Studio Code is recommended, and JavaScript, .NET, Ruby and Python programmers(developers) will feel right at home.

Both the official Visual Studio Code and IntelliJ plugins(drivers) support step-through debugging of Karate tests.

All you need is available in the karate-core artifact. You can run tests with this directly, but teams can choose the JUnit variant (shown below) that pulls in JUnit 5 and slightly improves the in-IDE experience.

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

Alternatively for Gradle:

testCompile 'com.intuit.karate:karate-junit5:1.4.1'

Also refer to the wiki for using Karate with Gradle dependencies.

If you mix Karate into a Maven(tools) or Gradle(tools) project with many other dependencies, you may run into problems because of dependencies conflicts. For example a lot of Java application projects directly (or indirectly) depend on Netty or Thymeleaf etc.

If you face any issues such as ‘class not found’, just pull in the karate-core dependency, and use the all classifier in your pom.xml (or build.gradle).

For example when using Maven:

<dependency>
 <groupId>com.intuit.karate</groupId>
 <artifactId>karate-core</artifactId>
 <version>${karate.version}</version>
 <classifier>all</classifier>
 <scope>test</scope>
</dependency>

Note that for very complicated projects you can consider using a Maven profile so that testing-related dependencies don’t collide with your development-time dependencies. Of course it is an option to have Karate tests in a separate stand-alone maven project and folder, while still being in the same Git repository.

It may be easier for you to use the Karate Maven archetype to create a skeleton project with one command. You can then skip the next few sections, as the pom.xml, recommended directory structure, sample test and JUnit 5 runners - will be created for you.

If you are behind a corporate proxy, or especially if your local Maven installation has been configured to point to a repository within your local network, the command below may not work. One workaround is to temporarily disable or rename your Maven settings.xml file, and try again.

You can replace the values of com.mycompany and myproject as per your needs.

mvn archetype:generate \
-DarchetypeGroupId=com.intuit.karate \
-DarchetypeArtifactId=karate-archetype \
-DarchetypeVersion=1.4.1 \
-DgroupId=com.mycompany \
-DartifactId=myproject

This will create a folder called myproject (or whatever you set the name to).

A Karate test script has the file extension .feature which is the standard followed by Cucumber. You are free to organize your files using regular Java package conventions.

The Maven tradition is to have non-Java source files in a separate src/test/resources folder structure - but we recommend that you keep them side-by-side with your *.java files. When you have a large and complex project, you will end up with a few data files (e.g. *.js, *.json, *.txt) as well and it is much more convenient to see the *.java and *.feature files and all related artifacts in the same place.

This can be easily achieved with the following tweak to your maven <build> section.

<build>
 <testResources>
 <testResource>
 <directory>src/test/java</directory>
 <excludes>
 <exclude>**/*.java</exclude>
 </excludes>
 </testResource>
 </testResources> 
 <plugins>
 ...
 </plugins>
</build>

This is very common in the world of Maven users and keep in mind that these are tests and not production code.

Alternatively, if using Gradle then add the following sourceSets definition

sourceSets {
 test {
 resources {
 srcDir file('src/test/java')
 exclude '**/*.java'
 }
 }
}

With the above in place, you don’t have to keep switching between your src/test/java and src/test/resources folders, you can have all your test-code and artifacts under src/test/java and everything will work as expected.

Once you get used to this, you may even start wondering why projects need a src/test/resources folder at all !

Let’s take a look at a few code snippets to see how Karate works in practice: This is a standard Spring Boot application that exposes two APIs

$ curl localhost:8080/api/hello
Hello world!

The fancy version when a name is passed in as a parameter…

$ curl localhost:8080/api/hello?name=Daas
Hello Daas!

Create a person

$ curl -X POST localhost:8080/api/person -H 'Content-type:application/json' -d '{"firstName": "John", "lastName" : "Doe", "age" : 30}'
42

Get a person by his/her id

$ curl localhost:8080/api/person/42
{"firstName":"John","lastName":"Doe","age":30}

The folder structure for Karate tests is given in the Karate documentation on folder structure, but the summary is that:

• All tests are defined in *.feature files
• For every feature file package, you need to have an empty test-class in the same package under src/test/java
• Karate recommends keeping the *.feature files in the same folder as the test-class
• The <build> section of the pom.xml needs a small tweak for this ..
• A similar change needed in build.gradle file.

A *.feature file has the same syntax as Gherkin/Cucumber and is also described in Karate documentation. The key points are

• Lines that start with # are comments
• There are three sections
• Feature : A name for the tests in this feature file
• Background : The steps in this section are executed before every Scenario in that file.
• Scenario : Each scenario is a test. A file can contain multiple Scenarios.
• Each scenario is described using
• Given : setting up the test
• When : the test action that will be performed
• Then : the expected outcome(s)

The karate-config.js file in the /test/java folder contains the environment and global variables used by Karate. This is is basically a javascript function that returns a JSON object. Which means that the file cannot contain any comment statements before the function body.

Logging configuration is controlled by the /test/java/logback.xml file as explained in the Karate documentation on logging.

On MacOs, you need to have an entry in your /etc/hosts file that contains an entry with your machine name. For example..

127.0.0.1localhost -MY-MACHINE-NAME-

This happens due to the way netty works in Karate. This issue is supposed to be fixed in Karate 1.0 (TODO — check if this is still valid for Karate 1.4 )

This repo contains a mix of unit tests (e.g., PersonServiceTests.java), spring-boot tests using TestRestTemplate (e.g GreetingControllerTests.java) and Karate Tests (*.feature file). There is also KarateTests.java which is a springboot tests that invokes all the karate tests.

There is no need to start the application when running the tests — that will happen automatically.

• From within IntelliJ …
• Right click on src/test/java and select "Run All Tests"
• The test results can be viewed in the browser at file:///<projectroot>/target/karate-reports/karate-summary.html
• From command line using Maven …
• Make sure that JAVA_HOME environment variable is pointing to Java 11
• mvn clean test
• From command line using Gradle …
• ./gradlew clean test

• IntelliJ -> Run -> HelloKarateApplication
• mvn spring-boot:run
• ./gradlew clean bootRun

The Karate framework is a versatile and powerful tool for test automation in today’s agile software development environment. Its unified approach, BDD integration, self-contained architecture, and native JavaScript support make it a favorite among testing professionals.

Give Karate a try, and experience faster and more efficient test automation that encourages collaboration and helps your team maintain high-quality software. If you’re looking to master test automation, Karate is a valuable addition to your toolkit. Get started today!

All Images Source : https://karatelabs.github.io/karate/