
Explore the karate framework for API automation and performance testing, powered by AI concepts, with hands-on script generation and practical examples for QA engineers.
Explore the karate framework as an open-source tool for API automation, data-driven testing, performance testing, and UI automation, with cucumber-style syntax and no step definitions.
Identify where materials and test steps are placed for upcoming sessions, and download the attached PowerPoint and code base zip to aid your test script creation.
Learn the prerequisites for the karate framework, including installing Java, configuring environment variables, and setting up Eclipse with Cucumber plugin, Maven, and Postman via the official website.
Learn to configure the karate framework with maven and JUnit 5, set up a sample feature and test runner, run a get request, and validate expected status codes.
Unpublish and delete the outdated karate configuration videos, and watch only the valid, up-to-date configuration lectures updated on September 5, 2020.
Configure Karate in a Maven project, part 2, by adding Karate JUnit dependency from io karate labs, using version 1.5.1, and run a sample feature to verify two scenarios pass.
Configure karate framework in VS Code via quickstart, customize group and artifact IDs in the pom.xml, and leverage Copilot to generate a feature file for get endpoints.
Compare com.intuit.karate and io.karatelabs, clarifying open source versus commercial versions, including cloud platform, advanced reporting, and professional support, while API, UI, and performance testing remain available.
Explore how Maven acts as a build automation tool to manage dependencies via pom.xml, project structure, and build lifecycles, with steps to create Maven projects and add JUnit dependencies.
Configure karate in IntelliJ by installing the community edition, creating a java project, adding karate arch type 1.4.1, installing cucumber for java, and running a simple get users scenario.
Explore the karate framework for API testing by understanding API basics, common request methods (GET, POST, PUT, DELETE), required inputs such as URL, headers, and JSON body, and response codes.
Explore rest architecture, web services, and how http requests and responses drive restful APIs using get, post, put, delete, and patch with json or xml representations.
Learn json basics, including objects, arrays, and nested structures, and use karate assertions to retrieve data from an api response, such as the second car or second pet breed.
Learn how cucumber BDD in the karate framework converts automation test cases into plain English using a jerkin language, with feature files, scenarios, and background.
Learn to construct a get request in the karate framework, use the open weather API as an example, and verify a 200 response with a cucumber-style feature and runner.
Explore using the get method with a Karate JUnit five runner class to call a rest API, verify 200 status, and run a get request scenario from a feature file.
Feature: validate variables concept
Background:
Given def company_name = "Lebyy.com"
Scenario: verify varaible data type
Given def employee_name = "surendra"
When def employee_id = 456
Then print employee_id
Then print employee_name
Then print "Employee ID value is", employee_id
Then print "Employee name is" ,employee_name
Then print "Company name is", company_name
Scenario: reuse of variable
Then print "Employee name is" ,employee_name
Then print "Company name is", company_name
Background:
Given url 'https://dummy.restapiexample.com'
Scenario: To get all employees information in JSON format
And path '/api/v1/employees'
And header Accept = 'application/json'
When method get
Then status 200
Scenario: To get specific employee details
And path '/api/v1/employee/1'
And header Accept = 'application/json'
When method get
Then status 200
Scenario: To get specific employee details
And path '/api/v1/employee/1'
And header Accept = 'application/json'
When method get
Then status 200
And print response.data.employee_salary
And print response.data.employee_name
And print response.data.id
And print response.data.employee_age
And print response.status
Explore how Karate framework generates an execution report after running a get scenario, including tag-based selection, a Karate summary HTML report, and details on status codes and failures.
Add assertions in Karate tests to verify status codes and validate response bodies using match contains, including checks for string or number types with dollar dot syntax.
Feature: Title of your feature
Background:
Given url 'https://dummy.restapiexample.com'
Scenario: To get all employees information in JSON format
And path '/api/v1/employees'
And header Accept = 'application/json'
When method get
Then status 200
And match header Content-Type == 'application/json'
And match response contains deep {"data":[{"id":1}]}
And match response contains deep {"data":[{"employee_name":"Caesar Vance"}]}
And match response.data == "#[24]"
#And match each response.data[*].employee_name contains "surendra"
And match response.data[*].employee_name == ["Garrett Winters","Tiger Nixon","Ashton Cox","Cedric Kelly","Airi Satou","Brielle Williamson","Herrod Chandler","Rhona Davidson","Colleen Hurst","Sonya Frost","Jena Gaines","Quinn Flynn","Charde Marshall","Haley Kennedy","Tatyana Fitzpatrick","Michael Silva","Paul Byrd","Gloria Little","Bradley Greer","Dai Rios","Jenette Caldwell","Yuri Berry","Caesar Vance","Doris Wilder"]
#Scenario: To get specific employee details
#And path '/api/v1/employee/1'
#And header Accept = 'application/json'
#When method get
#Then status 200
#And match response.data.employee_salary == 320800
#And match response.data.employee_name == "Surendra Jaganadam"
Convert a get request into a cucumber scenario outline with URL examples for data-driven testing. Store the response with def and print it to the console.
Explain how to perform a post request in Karate framework by passing a json body with given and request, validating a 200 response from a sample rest api.
Validate a get response for employees using match each to verify the complete data schema for every entry, including optional profile image, name, salary, id, and age.
Master running specific Karate scenarios by using tags and Karate options in the runner class, enabling targeted api tests and handling multiple hits.
Learn to call one karate framework feature file from another, reuse scenarios, and pass API responses by storing the description in a variable for cross-file usage.
Explore Karate assertions with examples part 2, including match, contains, equal, and not equal, and learn to verify data types (string, number, boolean, object, array) and null presence in responses.
Explore Karate schema validations in the Karate framework, validating api responses with array data, each item, numbers for counts and ids, strings for hashes, and optional fields using two hashes.
Explore Karate framework API automation with schema validations, using match each against the response data to align types for id, salary, and age and ensure successful assertions.
Feature: Validate embedded expressions
Scenario: To POST an entry using expressions
Given url 'https://reqres.in/api/users'
And header Accept = 'application/json'
Then def empName = "surendra jaganadam"
Then request { "name": '#(empName)',"job": "mobile automation tester" }
When method post
Then status 201
Scenario: To get all employees information in JSON format
Given url 'https://thetestrequest.com/authors/1.xml'
And header Accept = 'application/xml'
Then def authorName = "Surendra Lebyy"
When method get
Then status 200
And match response.hash.name == '#(authorName)'
Feature: validations with examples
#Scenario: To get all employees information in JSON format
#And url 'https://jsonplaceholder.typicode.com/posts/1'
#When method get
#Then status 200
#And def schemaVal = {"userId": '#number', "id": '#number', "title": '#string', "body": '#string'}
#Then match response ==
#"""
#'#(schemaVal)'
#"""
Scenario: To get all employees information in JSON format
And url 'https://jsonplaceholder.typicode.com/posts/1/comments'
When method get
Then status 200
And def schemaVal = {"postId": '#number',"id": '#number', "name": '#string',"email": '#string',"body": '#string'}
Then match response ==
"""
'#[] #(schemaVal)'
"""
@wilson1
Scenario: Title of your scenario
Given url 'https://gorest.co.in/public/v2/users'
When method get
Then def outputData = []
#Then print response[0]
And eval for(var i=0; i<response.length; i++) if(response[i].name.endsWith("Butt")) outputData.push(response[i].email)
Then print outputData
Explore conditional statements using if and a for loop in karate framework to filter a JSON array from a get response, capture targeted user data (email, gender), and print results.
Demonstrates how to compare multiple input emails with API responses using a get request, iterating over results, and validating matches with a cucumber feature.
Learn to read data from a Java class and use it in a Karate feature file by creating a Java reader with methods that return lists or maps.
Learn how to store API responses in external files using karate framework, write outputs to text files, and validate UI content against API data for automated tests.
#Feature: Execute Java Script Function
#Scenario: validate js code 1
#Then def getValue = function() { return "surendra"; }
#Then print "function outpiut is ", getValue()
#Scenario: Function to add 2 numbers
#Then def sumValue = function(a,b) { return a+b; }
#Then def sumValue = function(a,b) { return a-b; }
#Then print "sum value os " , sumValue(100,150)
#Then print "sum value os " , sumValue(100,10)
#Scenario: Random Number
#Then def random = function() { return Math.random(); }
#Then print "random no is ", random()
Learn to configure Karate parallel execution with JUnit (4/5), create a parallel runner, specify feature paths and tags, set a parallel count, and run scenarios concurrently across threads.
Configure and run parallel karate tests from multiple feature locations using the runner.part and optional tags. Set environment and reports data directory, and control parallelism with the parallel count.
convert a post test to a scenario outline in Karate framework, using examples to supply name, salary, and age for a data-driven post request that inserts a record.
Learn how to read data from a csv file in Karate framework, convert it to json, and print retrieved data from a project csv.
Read data from a CSV file and pass it in a post request to drive API automation. Use scenario outlines or CSV data to supply multiple data sets.
Feature: Demo
Scenario: To get specific employee details
Given url 'https://dummy.restapiexample.com'
And path '/api/v1/employee/1'
And header Accept = 'application/json'
When method get
Then status 200
Given def expected_Response_Data = read("/ApplicationResponse.json")
#Then print expected_Response_Data
Then match response == expected_Response_Data
Scenario: To get all employees information in JSON format
Given url 'https://thetestrequest.com/authors.xml'
And header Accept = 'application/xml'
When method get
Then status 200
Given def expected_Response_Data = read("/ResponseData.xml")
#Then print expected_Response_Data
Then match response == expected_Response_Data
Scenario: To POST an entry
Given url 'https://reqres.in/api/users'
And header Accept = 'application/json'
Then def input_json_body = read("/inputData.json")
Then request input_json_body
When method post
Then status 201
Create a test Jira account for API automation, including email signup, public email usage, verification, and setting up a scrum project to access API token details.
Explore using the Jira API for authentication and user data with API tokens and account IDs, and convert curl to Postman for the Karate framework automation.
Apply basic authentication in the Karate framework to retrieve user details with a get request, using a basic auth script and header authorization, and validate a 200 response.
Explains implementing OAuth authentication for a Salesforce app by generating an access token in a Java method and using it in a Karate test with a bearer header.
Create a Jira user with a post request using basic authentication, demonstrating curl and Postman workflows, including json body, api token, and domain url setup.
Feature: Validate File uploading flows
#Scenario: To POST an entry using expressions
#Given url 'https://chinnapavanm.atlassian.net/rest/api/3/issue/SCRUM-4/attachments'
#And header X-Atlassian-Token = 'no-check'
#Then header Authorization = call read('basic-auth.js') { username: 'chinnapavanm@gmail.com', password: 'ATATT3xFfGF0YQhLo-aH0Trjmg9kKyOBRMtVm-XXjuvVbTRJKBnElzEK-Piy15ISv0eUKbLyzh-tGdM9IxTCVgw8db0TmyANCbLviW6nPVH1jBUlvUXD-Taz_reudDCRwksq-EbwDWm-7d-Geab3DyW0_iY3xqFI_s6KUuzBQD3ZEHvYzZ7F08w=CE46325B' }
#Then multipart file file = { read: 'ApplicationResponse.json', filename: 'ApplicationResponse.json', Content-Type: 'multipart/form-data' }
#When method post
#Then status 200
Scenario: To POST an entry using expressions
Given url 'https://chinnapavanm.atlassian.net/rest/api/3/issue/SCRUM-4/attachments'
And header X-Atlassian-Token = 'no-check'
Then def fileLocation = '/data/README2.txt'
Then header Authorization = call read('basic-auth.js') { username: 'chinnapavanm@gmail.com', password: 'ATATT3xFfGF0YQhLo-aH0Trjmg9kKyOBRMtVm-XXjuvVbTRJKBnElzEK-Piy15ISv0eUKbLyzh-tGdM9IxTCVgw8db0TmyANCbLviW6nPVH1jBUlvUXD-Taz_reudDCRwksq-EbwDWm-7d-Geab3DyW0_iY3xqFI_s6KUuzBQD3ZEHvYzZ7F08w=CE46325B' }
Then multipart file file = { read: '#(fileLocation)', filename: 'README2.txt', Content-Type: 'multipart/form-data' }
When method post
Then status 200
Learn how to drive api automation using data from csv: convert data to a scenario outline, map csv fields to post inputs, and create multiple accounts via post requests.
Define and use a karate config file to supply environment-specific values like app base URL, app id, and app secrets, enabling runtime data substitution in feature tests.
Read environment data from the karate config file to define environment-specific values, map karate.env (dev, AE2E) to URLs, and print the environment during test execution.
Scenario: validate jsonpath
And url 'https://jsonplaceholder.typicode.com/posts/1/comments'
When method get
Then status 200
Then print karate.jsonPath(response,"$.[0].email")
Then print karate.jsonPath(response,"$.[?(@.id==1)].name")
Refer below link which has examples what we discussed in the session:
https://github.com/json-path/JsonPath
Update the karate runner to pass environment values via karate.env, defining the env and validating that the updated value (for example dev ww.com) is published during test execution.
Integrate cucumber reports into the karate framework by adding the cucumber reporting dependency (latest 5.7.0) and updating pom.xml, then generate and view detailed cucumber html reports of test execution.
Trigger karate scripts from the command line using mvn test, with options to specify test runner class and environment, and pass karate options like tags and features.
Learn to run karate framework test scripts from Jenkins, configure a freestyle job with a custom workspace, and execute mvn test -D runner on Mac or Windows.
Learn to use hooks in the karate framework, employing background for before scenario content and after scenario and after feature hooks to manage preconditions, postconditions, and after execution steps.
Scenario: To get all author information in xml format
Given url 'https://thetestrequest.com/authors.xml'
And header Accept = 'application/xml'
When method get
Then status 200
#And match response/objects/object[1]/email == 'viva@keebler.biz'
And match /objects/object[1]/email == 'viva@keebler.biz'
Scenario: To get author information in xml format
Given url 'https://thetestrequest.com/authors/1.xml'
And header Accept = 'application/xml'
When method get
Then status 200
And match response/hash/name == 'Karl Zboncak'
Learn to perform karate API testing with Gatling by turning karate tests into load scenarios, configuring maven plugins, and validating responses in Gatling reports.
Configure karate Gatling in a Maven project using Visual Studio Code, add the pom.xml dependency and Gatling and Scala Maven plugins, and enable GitHub Copilot for assistance.
Learn how to configure Karate Gatling for performance testing: create a performance folder, update the Gatling plugin to 4.2.1, and set up config and data folders, troubleshooting missing simulations.
Create a perf runner class extending Gatling's simulation to run Karate feature files, configure Gatling and Karate protocols, define a scenario, and set up ramp-up load for performance testing.
Learn how to configure the karate protocol to aggregate multiple get requests into a single Gatling report by assigning a dynamic id to null, with post-by-id examples.
Explore the karate name resolver, an optional feature that returns null by default but can generate a customized name when you add a header named karate name.
Learn the karate protocol pauseFor() feature with a get request delay example, configuring per-url delays in milliseconds and observing 10s, 20s, and 30s total delays across three scenarios.
Explore how think time in karate gatling simulates user pauses between http requests with karate dot pass, avoiding thread.sleep and revealing delay effects on request-per-second metrics.
Discover how to use the Karate runner when needed, configure environment values with config.js via a config dir, and set system properties to control base URLs for different environments.
Learn to use the karate data feature to tag scenarios in a feature file with the tag selector, enabling running only selected scenarios (e.g., @regression) and reviewing targeted reports.
Learn to ignore or run specific test scenarios in Karate framework API automation by tagging with regression and smoke, combining tags, and executing selected tests.
Explore using GitHub Copilot to extract Gatling session data in Karate feature files, printing and inspecting user id, token, and role from the Gatling session during a smoke test.
Use Karate Gatling feeders to load CSV data into a scenario, retrieve the Gatling session details, and print email and username during API automation.
Explore feeding user data in Gatling via a csv feeder and json test data, substituting username and email in the request body.
Learn Gatling’s csv feeder strategies: iterator, random, shuffle, and circular, and see how data is consumed by virtual users, including circular wrapping when data runs out.
Learn to use a JSON feeder in Gatling to read email and password data from a JSON file, specify the file path, and ensure the root element is an array.
Explore injection scenarios in open and closed workload models, focusing on arrival rate versus concurrency. Demonstrate at once users, durations, and basic requests-per-second visuals to simulate load patterns.
Apply ramp up and constant users per second strategies to simulate load, distributing 20 users over five seconds and reviewing requests per second in the resulting report.
Explore injection open model example 3 and ramp up load from 5 to 10 users per second over five seconds with Gatling, and analyze requests per second.
Learn to automate the get all dashboards endpoint using the Karate framework, including basic auth setup, importing curl commands, and end-to-end dashboard validation.
Create a dashboard using the karate framework for api automation, configuring a post request with a json payload, and validating with postman and curl.
Learn how to retrieve all gadgets using a get request, update the endpoint url, email, and token, and validate results with curl and postman.
Learn to add a gadget to a dashboard using curl and Postman, updating the dashboard ID, URI, and gadget title, and validating the request with a successful 200 response.
Delete a gadget from a dashboard using a delete request with the correct dashboard and gadget IDs. Validate removal by refreshing the dashboard and reviewing the updated gadget list.
Update a dashboard with a put request using curl or postman, providing the dashboard id and a payload with name, description, and type, then verify by refreshing dashboards.
Feature: Verifying end points as per the request
#Scenario: Verify country codes
#Given url 'https://restcountries.com/v3.1/alpha/GB'
#When method get
#Then status 200
#Then print response[0].capital[0]
#And match response[0].capital[0] == 'London'
Scenario Outline: Verify country codes
Given url 'https://restcountries.com/v3.1/alpha/<code>'
When method get
Then status 200
#Then print response[0].capital[0]
And match response[0].capital[0] == '<country>'
Examples:
|code|country|
|GB |London |
|FR |Paris |
|JP |Tokyo |
<dependency>
<groupId>com.intuit.karate</groupId>
<artifactId>karate-junit5</artifactId>
<version>1.4.1</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.intuit.karate/karate-core -->
<dependency>
<groupId>com.intuit.karate</groupId>
<artifactId>karate-core</artifactId>
<version>1.3.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.intuit.karate/karate-apache -->
<dependency>
<groupId>com.intuit.karate</groupId>
<artifactId>karate-apache</artifactId>
<version>0.9.6</version>
<scope>test</scope>
</dependency>
Explore the fundamentals of artificial intelligence and how AI learns, processes data, and thinks like a human. It covers language, image recognition, automation, and real-world uses behind Siri and maps.
Explore how AI augments human work with a human-in-the-loop approach, boosting testing and development efficiency, including postman versus soap UI and AI-generated manual and automated test cases.
Explore large language models as a human brain for AI, trained on vast data to translate, answer, summarize, and generate images, with GPT-4, Claude-3, Gemini, and LaMDA.
Generative AI creates new content by synthesizing information trained on massive datasets, unlike traditional AI that analyzes existing data; it can generate code, documents, audio, video, and text from images.
Explore how retrieval augmented generation enhances LLM responses by using a vector database of embedded information to retrieve relevant data and augment queries, enabling accurate answers without full retraining.
Explore how AI memory stores and recalls past interactions to enable meaningful conversations. Distinguish short term memory, active within a session, from long term memory, which persists across sessions.
Explore how an AI agent independently uses tools to achieve a goal by perceiving its environment, planning actions, executing them, and adapting based on results.
Explore LangChain and LangGraph, showing how vector databases, data chunking, and embeddings connect LLMs to external data sources, with graph-based AI agent workflows of nodes, edges, states, and checkpoints.
Discover the model context protocol (MCP), a standard bridge enabling AI models to discover, call, and understand external tools consistently and safely.
Explore the human in the loop concept, why ai should seek human approval for critical decisions, and how guardrails and prompt engineering prevent hallucination and protect information.
Learn how fine tuning updates the existing knowledge base in AI agents to tailor interactions for customers, branch staff, and leaders, and how this differs from RAG using external knowledge.
Learn why context matters for language models and LMS performance; providing precise information helps models follow rules and produce more accurate, engaging outputs.
Explore prompt engineering and how clear, contextual prompts shape AI responses, reduce hallucinations, and enable turning input into actionable plans.
Set a context for an LLM to act as a tester using a text file with rules, then generate manual or automation test cases from user stories and UI mockups.
Explain how to define a manual context file to guide ChatGPT in executing login flow tests, including positive and negative cases, and the role of prompts for automation.
Explore zero-shot, one-shot, and few-shot prompts, and chain-of-thought reasoning to guide LLMs in automation testing. Learn how to design context files and page locator syntax to improve test framework outputs.
Compare ChatGPT, GitHub Copilot, and Cursor for coding and automation testing; learn how Copilot and Cursor integrate with editors to adapt to existing frameworks and boost development precision.
Explore how OpenAI powers ChatGPT and Copilot, introduce GPT models and Dall-E, and explain the principles and protocols guiding OpenAI's AI development.
Define AI models as data-trained algorithms that recognize patterns and generate outputs, such as human-like text and images, and distinguish them from llms like GPT and DALL-E.
Explore how n8n enables workflow automation by creating ai agent and building nodes and workflows to automate tasks like onboarding emails and data retrieval without code during a 14-day trial.
Learn to generate an OpenAI API key from the quick start, securely copy and store it, and use it to connect AI agents for automation tasks.
Create a simple n8n workflow that connects Gmail and Google Drive, reads a test data sheet, and uses an AI agent with GPT-4.1 mini to email Sam’s row.
Build a dynamic n8n workflow that checks a sheet for a jam user, lets the AI agent determine the recipient at runtime, and emails the matched recipient.
Explore building and tweaking an n8n workflow that reads sheet data, triggers background verification emails when status is S, and handles multiple candidates via Google Sheets integration.
Create a Jira cloud account, generate an API token, and set up a project with Zephyr Squad to read inputs from Excel and create test cases or defects in Jira.
Explore building an n8n workflow to pull new defects from a data sheet and create Jira issues, including configuring credentials, domain, and project, while debugging connection issues.
Learn how to configure an n8n workflow to create Jira bugs from sheet data, including credentials, URL handling, connection testing, and automating defect creation for new issues in a project.
Create a public chat in an n8n workflow and publish a URL, enabling interactive ai assistant responses, while automating defect creation and issue tracking from a google sheet.
Discover that tokens are the fundamental units of words and punctuation in OpenAI prompts—four characters per token—driving processing time and cost. Learn to manage tokens for budgets and rate limits.
Create a chrome extension for record and playback using Cursor AI to generate Playwright or Selenium scripts, guiding from prompt to npm install, build, and load unpacked in Chrome.
Explore building a Chrome extension for record and playback with Cursor AI, capturing actions to auto-generate test scripts in Playwright TypeScript or Selenium, with playback and download.
Develop an OTP shield mobile app that monitors text messages, phone calls, WhatsApp messages, and WhatsApp calls, warns against sharing OTP, blocks APK files, and offers a dismiss option.
Learn how GPT4All lets you run LLMs locally, offline and private on your machine. The lecture demonstrates downloading, configuring models, and generating manual test cases from project documents.
Generate karate api test cases in eclipse with GitHub Copilot, creating karate feature files with given when then steps and updated headers, authentication, and curl-to-karate conversions per Jira Cloud docs.
Generate karate api test cases using copilot in vscode editor, creating a user via a feature file, configuring api context, handling authentication, and validating responses with curl commands and assertions.
Demonstrates generating a karate api test case using cursor editor within eclipse, creating a get user email feature, and troubleshooting a 400 error while using ai as a helper.
Explore creating local agents as alternatives to NA10 and define behavior with agent.md and skills.md for manual test cases and automation scripts.
Create an Azure dev apps free account, sign up, verify with an otp, and set up an organization and project to run playwright automation in pipelines.
Develop a custom manual test case generator agent that fetches an Azure DevOps story, creates and saves test cases per defined rules, and optionally uploads them to Azure.
Develop a Python-based manual test case generator agent that fetches azure dev apps user stories, prints title, description, acceptance criteria, and saves ui mocks as screenshots/story_number.png.
Define and generate comprehensive manual test cases with end-to-end journeys, negative and edge cases, using P1 and P2 priorities, and actionable steps like navigate and click, saved as story-id.md.
Provide an update on upcoming AI videos, expanding the AI series with 12 plus videos, updating content, generating test scripts, and building a framework within one week.
** Updated with Karate Gatling performance testing & AI-driven implementation **
Learn Karate Framework for API automation and performance testing — Karate DSL, REST API testing, Gatling performance, project practice, and AI-assisted Karate workflows.
This Karate API testing course is built for manual testers, beginners, and QA engineers who want practical API and performance automation skills without heavy coding overhead.
What you will learn in this course:
- Karate Framework setup and Karate DSL fundamentals
- REST API automation with GET, POST, PUT, DELETE
- Assertions, JSON handling, and data-driven testing
- Reusable scenarios and maintainable Karate test design
- Performance testing with Karate and Gatling
- Mini project practice (JIRA API workflows)
- AI-driven implementation concepts for Karate automation
- Interview and real-project problem solving topics
Keywords covered in this course:
Karate Framework, Karate DSL, Karate API testing, REST API automation, Karate performance testing, Gatling with Karate, API automation testing, Karate from scratch, data driven API testing, AI for QA, Karate Gatling.
This course focuses on hands-on Karate implementation so you can confidently automate APIs and run performance tests for projects and interviews.
If you are searching for Karate Framework, Karate DSL, Karate API automation, or Karate Gatling performance testing training, this course is for you.
Course is updated on 8-December-2025 with below concepts::
Overview on AI
Overview on LLM
Overview on RAG
Overview on Generative AI
Overview on Memory
Overview on AI Agent
Overview on LangChain & LangGraph
Overview on MCP Server
Overview on Human In the loop , Hallucination & Guardrails
Overview on Fine-Tuning
Overview on Context
Overview on Prompts
ChatGPT vs CoPilot vs CURSOR
Overview on OpenAI
Overview on AI Models
Overview on n8n workflow
Generate API Key in OpenAI
Create workflow in n8n
Create Public Chat in n8n workflow
Overview on OpenAI Tokens
CURSOR - Create a Chrome Extension for Record & Playback
CURSOR - Create an OTP Shield Mobile APP
Generate Karate API Test case using CoPilot in Eclipse Editor
Generate Karate API Test case using CoPilot in VSCode Editor
Generate Karate API Test case using Cursor Editor
Course is updated on 24-August-2025 with below concepts::
Performance Testing using Gatling
Introduction to Karate-Gatling
Karate-Gatling configuration
Overview on Karate Protocol
Overview on Name Resolver
Pause For & Think time with examples
Karate feature - Tag Selector & Ignore Tags
Overview on Feeders - Reading data from csv & json
Overview on Open model injection with examples
Course updated on 27-March-2025:
Configure IntelliJ Editor for karate Framework
Course updated on 29-January-2025:
. Karate UI - How to compare images
Course updated on 21-November-2024:
How to handle Error: Could not find or load main class cucumber.api.cli.Main ???
Course updated on 06-August-2024:
XML Response Validations
Course updated on 30-July-2024:
Configuring Karate Framework with example -> Couple of students asked to update the content hence created this video
API Automation Made Simple using Karate framework
Karate Framework for beginners
API Automation with Karate Framework.
API Automation using Karate Framework
Karate Framework
Karate is an open-source general-purpose test-automation framework that can script calls to HTTP end-points and assert that the JSON or XML responses are as expected. Karate is implemented in Java but test-scripts are written in Gherkin since Karate was originally an extension of the Cucumber framework.
Karate is built on top of Cucumber, another BDD testing framework, and shares some of the same concepts. One of these is the use of a Gherkin file, which describes the tested feature. However, unlike Cucumber, tests aren't written in Java and are fully described in the Gherkin file.
From this course, you will learn the following concepts.
Karate configuration
Overview on API with examples
Overview on JSON with examples
Live example of API calls
Karate Framework
GET/POST Request
Data-Driven with Scenario Outline
Creating Parallel runner
Assertions
Using match
JSON Array matching
Schema validation
Fussy matcher: #string, #number
calling another feature
Tags and Run with tags
karate runner configuration and karate options
Report Generation
Cucumber Report Generation
Karate Report Generation
Karate framework HOOKS
How to Handle SSL Handshake error
How to resolve initialization error in karate framework after configuration