Karate for VS Code

Karate is an open-source test-automation framework.

This extension is brought to you by Karate Labs. Find it at the Visual Studio Marketplace or Open VSX Registry.

Ready To Run

No extra installation or setup is required. Everything needed to write and run Karate scripts is included.

PLUS and PRO

To run tests you require at least a PLUS subscription. A PRO level gives you a lot more, including debug support. Refer to the documentation below on how to sign-in.

Pricing information can be found on our website. If you need more information, please Contact us.

PLUS Features

• API testing, API mocks, and UI / web-browser automation
• Syntax coloring
• Code Formatting
• Outline view
• Embedded JS highlighting
• Run CodeLens (requires PLUS or PRO subscription)
• Color log output
• One-click to open HTML report
• Extra run modes (configurable via extension settings)
  • Maven
  • Custom (e.g. for Gradle or stand-alone JAR)
• Works in remote environments (e.g. GitHub Codespaces, Gitpod, Devcontainers / Docker)

PRO Features

How to Sign In

Use the "Accounts" toolbar in VS Code (usually on the bottom left, see screenshot below).

If you don't see the option to Sign in with Karate make sure you have opened a folder with a *.feature file in it to activate the plugin

• It also can happen that another plugin has "taken control" of *.feature files, so make sure that when you open a Karate feature file - you can see Karate as the "Language Mode" in the bottom right corner of VS Code (in the status bar)
• You can explicitly set the language mode by clicking on the current mode (e.g. Gherkin) and selecting Karate from the list. Or go to View --> Command Palette and search for Change Language Mode

Once signed-in, you will not be prompted again for 30 days. New subscribers will be taken through a purchase flow. You can manage your subscription at studio.karatelabs.io.

See a 30 second video here.

Editing Classpath

To add custom JAR files to the runtime (in default "bundled" run mode), you can follow these instructions. This is needed if you want to use Karate Robot for Windows desktop automation.

Using a specific Karate version

For convenience, the Karate Visual Studio Code extension embeds the latest version of Karate (in default "bundled" run mode). Teams maintaining large test-suites using advanced features may want to "lock-down" the version of Karate used, which is important when collaborating within a team and running tests in Continuous Integration. Refer to this wiki page for more: Run Mode - Custom.

Maven or Gradle

You should change extension settings to switch the run more to "maven" or "custom". Maven should just work without needing to tweak the default command-line settings. For Gradle and custom needs, refer to this wiki page for more: Run Mode - Custom.

Command Line

Once you are familiar with Karate and have created a few tests, you may want to run them from the command-line. You have two options:

• Use the stand-alone JAR, recommended if you are new to programming
• use a standard Java Maven or Gradle project, and you can refer to the Karate examples for sample "starter" projects.

K-Flow

K-Flow is an enterprise solution that solves for API documentation, with a focus on end-user workflows. The highlights are:

• A no-code interface for creating, editing and previewing these flows
• First-class support for OpenAPI and Swagger
• Export to pure-HTML for publishing or internal-collaboration
• Showing how multiple APIs are called in sequence as a business workflow
• Showing variations of a given API due to business-rules

K-Flow is a separate upgrade from Karate Pro. For more details on pricing and features, refer to our website.

Debug

• In Pro mode, a Debug codelens appears next to the Run >> option.
• Set break-points and even step-back in time.
• Save time with the hot-reload feature without needing to re-start your flow.
• Interact with a live session using the VS Code debug console.

See a 1 minute video here. If you are using Maven or Gradle, refer to the instructions here to set up your project for debugging: Debug Server.

Code Folding

JSON Formatting

Run Mode

Easily switch run-mode.

Run Options

Easily edit Karate run-options.

Context Menu

• Right-click in the explorer view to run all tests in a folder.
• You can even start mocks (see OpenAPI import for more about mocks).

Postman Import

OpenAPI Import

• All versions including Swagger support.
• Documentation on the new JS mocks in Karate can be found here.
• For extra insights, refer to this presentation at the API Specifications Conference 2022.
• A sample project can be found here: karate-oas-demo.

See video here.

cURL and HAR Import

• You can double-click on unused space in the VS Code editor (tab) and use the text-editor as an import source.
• This works even on the JavaScript used in Postman "Tests" so that you can troubleshoot the importing of complex collections.
• All supported formats supported via plain-text this way:
  • cURL
  • HAR
  • Postman
    • Collections
    • Tests / Assertions JS
  • Swagger
  • OpenAPI

Inline Reports

View summary and Feature / Scenario reports without leaving your IDE. This is especially useful when using a remote development environment such as GitHub Codespaces.

Watch this video to get a feel of the enhanced Developer-Experience.

You can also see all HTTP calls made during a test.

Launch Configurations

In "Pro" mode, the plugin supports VS Code launch configurations in the .vscode/launch.json file. Here is an example configuration:

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "karate",
            "name": "env-test",
            "request": "launch",
            "feature": "${file}",
            "karateArgs": [
                "-e",
                "test"
            ]
        }
    ]
}

The advantage is that you can set up any combination of Karate runtime options via karateArgs. For example you can:

• run tests in parallel
• set the environment
• or choose tags to include or exclude.

Now you can run tests from the Run and Debug view in VS Code and keyboard short-cuts such as F5 will work for the currently focused file in the editor. Note that you can even Run without Debugging: Ctrl + F5.

You can have multiple configurations and easily switch between them.

You can add "noDebug": true to the run-configuration JSON to force "Run without Debugging" for convenience.

Instead of ${file} as the value for feature, you can use any valid folder path or even multiple feature files.