This session aims to shed some light to an emerging test automation framework Karate DSL. This framework resolves many of the test automation problems by having API test-automation along with performance-testing and UI Web Automation testing into a single, unified framework.

1. Getting Started with Karate-DSL
Presented by : Sparsh Bhardwaj
QA Consultant

2. Lack of etiquette and manners is a huge turn off.
KnolX Etiquettes
Punctuality
Respect Knolx session timings,
you are requested not to join
sessions after a 5 minutes
threshold post the session start
time.
Feedback
Make sure to submit a
constructive feedback for all
sessions as it is very helpful for
the presenter.
Silent Mode
Keep your mobile devices in
silent mode, feel free to move
out of session in case you need
to attend an urgent call.
Avoid Disturbance
Avoid unwanted chit chat during
the session.

3. Our Agenda
01 What is Karate DSL?
02 Why Karate?
03 Performance Testing with Karate
04 UI Testing with Karate
05 Demo

4. What is Karate?
● Karate is the only open-source tool to combine API test-automation,
Performance testing and even UI Automation into a single, unified
framework
● Karate is a testing framework that can be used for automation of any
project.
● It is easy to understand and writing the code does not require much
complex programming skills.
● Karate follows BDD ( Behavior Driven Testing ) which uses Cucumber /
Gherkin for writing the test cases.

5. What does Karate offers?
● Tests can be easily parallelizable. When the number of tests gets big, you know
that you have no choice but running tests in parallel to save time and reduce the
CI/CD cycles duration.
● Makes you less lazy to write tests, it promotes code reuse .In large projects,
sometimes one refrain from testing more scenarios because he thinks he has done
enough testing. Some testing scenarios are close and you, as developer, think that
there is no need to write an additional test, and this can result in a decrease in
coverage
● As a tester, we need to have these key feature in our testing framework to increase
productivity.

7. Why are we using Karate?
● Karate supports both frontend and backend testing.
● Easy for even non-programmers to get started.
● Re-use functional tests as performance tests.
● Karate has built-in JSON and XML assertions so it becomes very easy to
validate the responses from the API.

8. Features of Karate DSL
● Karate supports DSL ( Domain Specific Language ) has syntax which
supports json.
● Karate is intelligent enough to help us debug our failing tests which tells us
exactly where and what the issue is.
● Built-in support for switching configuration across different environments
(e.g. dev, QA, pre-prod)
● Cross browser Web UI Automation so that you can test all layers of your
application with the same framework

9. Folder structure of Karate
● 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 the creators of the Karate tool
recommend that you keep them side-by-side with your *.java files.

11. Test Runner
● This is a simple java class used to run our test cases using cucumber
tags.
● We create unique tags for writing test cases so that we can easily run
them.
● /**Cucumber Option to run Karate API*/
@KarateOptions(tags={"@Demo"},
features = {"src/test/java"})
@RunWith(Karate.class)
public class TestRunner {
}
● This is all we need

12. Performance Testing With Karate
● Re-uses Karate tests as performance tests executed by Gatling.
● Uses Gatling (and Scala) only for defining the load-model, everything else
can be in Karate.
● Karate assertion failures appear in Gatling report, along with the
line-numbers that has failed.

13. Gatling Setup
● We just need to add this plugin, and we are good to go
<groupId>io.gatling</groupId>
<artifactId>gatling-maven-plugin</artifactId>
<version>3.0.2</version>
● We don’t need anything else, we just need call our .feature file in the
gatling script and we are all set.

14. ● This could not get any easier than this. This is the most basic script, we just need to add
assertions and just need to setup simulation injections.
import com.intuit.karate.gatling.PreDef._
import io.gatling.core.Predef._
import io.gatling.core.scenario.Simulation
class GatlingTest extends Simulation{
val getTest = scenario("get the feature
file").exec(karateFeature("classpath:Performance/sample.feature"))
setUp(getTest.inject(atOnceUsers(users = 1)))
}

16. ● The Gatling performance report shows where the error has occurred with the
line number as well. Like in the example below, the assertion has failed on
the line number 7 in the feature file.

17. UI Automation with Karate
● No need to learn complicated programming concepts of UI testing such as
“callback” and “await”.
● Simple retry and wait strategy, no need to have the knowledge to understand
the use and the difference between implicit waits, explicit waits and fluent
waits.
● You will often need to move steps (for e.g. a login flow) into a common feature
that can be called from multiple test-scripts. You can call that login feature into
your current feature file so that our test suite can become more granular and
easy to handle.

18. ● The most persistent problem with UI Web automation is waiting for DOM
elements to become available for interaction or to disappear from the DOM
tree to continue the test is hard to do for some web applications.
● Sometimes you just end up with hard waits, waiting for some milliseconds or
seconds and then continue with the test.
● This is bad because these idle times add up over the test run and can
significantly increase the runtime of a complete test suite.
● Selenium is that it does not generates test report on its own. We need
TestNg or something like that. In Karate we can have a more detailed report
through JUnit and Cucumber-reporting.
What does Karate solves in UI automation?

19. Script Description
waitFor(#id) This is typically used for the first element you need to interact with on a
freshly loaded page
retry(10).waitFor(#id) like the above, but temporarily over-rides the settings to wait for a
longer time.
waitForText(‘#id’,’appeared’) frequently needed short-cut for waiting until a string appears
waitForUrl(url) for convenience, this uses a string contains match – so for example
you can omit the http/https prefix
This is enough to make statement that Karate bests Selenium in the waits.

20. Demo

21. Q&A

22. Thank You