Karate Soap Testing Example: All You Need to Know

Soap testing is a critical aspect of software development, and karate is a tool that has proven highly efficient in testing SOAP-based web services. Soap UI and Postman are popular tools that have been used for testing, but Karate has quickly gained popularity due to its ease of use, ability to perform complex tests, and ability to generate reports. In this article, we will delve into everything you need to know about Karate soap testing using a practical example.

What is Karate?

Karate is an open-source tool that allows for testing of APIs using a simple, easy-to-read language. It functions as an automation framework that enables the creation of automated tests, and because it is lightweight, it can be easily integrated with various tools in the devops chain. Karate is gaining much attention in the software testing industry because it offers a host of features that make it a more efficient testing tool compared to existing solutions. Unlike Postman or Soap UI, Karate is a test automation framework that is built on top of Cucumber and does not require extensive coding knowledge.

Functionalities of Karate

Karate is a comprehensive tool that offers a wide range of functionalities that facilitate software testing. Some of the notable features include:

• Easy handling of complex data structures, including JSON, XML, tables, and binary data
• Integrated reporting
• Ability to mock servers
• Ability to interact with databases and web browsers
• Support for parallel execution
• Support for multiple protocols like HTTP, HTTPS, WebSockets, and TCP
• Integration with Continuous Integration (CI) tools like Jenkins, Travis, and Bamboo

Karate Soap Testing Example

Now let’s dive into a Karate Soap testing example. First, we’ll create a simple SOAP-based web service so that we can execute tests against it. Our Web Service is a simple calculator that will receive two integer numbers, a and b, and return the summation of the two numbers. Our WSDL file will look like this:

    <definitions name="CalculatorService" targetNamespace="http://soaptest.example.com/ws/calculator/" xmlns="http://schemas.xmlsoap.org/wsdl/">
        <types>
            <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://soaptest.example.com/ws/loan/CalculatorService">
                <xsd:element name="addNumbersRequest" type="tns:addNumbersRequest"/>
                <xsd:complexType name="addNumbersRequest">
                    <xsd:sequence>
                        <xsd:element name="a" type="xsd:int"/>
                        <xsd:element name="b" type="xsd:int"/>
                    </xsd:sequence>
                </xsd:complexType>
                <xsd:element name="addNumbersResponse" type="tns:addNumbersResponse"/>
                <xsd:complexType name="addNumbersResponse">
                    <xsd:sequence>
                        <xsd:element name="result" type="xsd:int"/>
                    </xsd:sequence>
                </xsd:complexType>
            </xsd:schema>
        </types>
        <message name="addNumbersRequest">
            <part name="payload" element="tns:addNumbersRequest"/>
        </message>
        <message name="addNumbersResponse">
            <part name="payload" element="tns:addNumbersResponse"/>
        </message>
        <portType name="CalculatorServicePortType">
            <operation name="addNumbers">
                <input message="tns:addNumbersRequest"/>
                <output message="tns:addNumbersResponse"/>
            </operation>
        </portType>
        <binding name="CalculatorServiceSoapBinding" type="tns:CalculatorServicePortType">
            <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
            <operation name="addNumbers">
                <soap:operation soapAction=""/>
                <input>
                    <soap:body use="literal"/>
                </input>
                <output>
                    <soap:body use="literal"/>
                </output>
            </operation>
        </binding>
        <service name="CalculatorService">
            <port name="CalculatorServicePort" binding="tns:CalculatorServiceSoapBinding">
                <soap:address location="http://localhost:8123/ws/calculator"/>
            </port>
        </service>
        <!-- end-wsdl -->
    </definitions>

After we have the WSDL file, we can create the SOAP service implementation by implementing the endpoint interface. Here is what the implementation would look like:

@WebService(targetNamespace="http://soaptest.example.com/ws/calculator/",
        serviceName="CalculatorService",
        portName="CalculatorServicePort",
        wsdlLocation="META-INF/wsdl/CalculatorService.wsdl")
public class CalculatorServiceImpl implements CalculatorService
{
    @Override
    public AddNumbersResponse addNumbers(AddNumbersRequest parameters)
    {
        int a = parameters.getA();
        int b = parameters.getB();
        int result = a + b;
        AddNumbersResponse response = new AddNumbersResponse();
        response.setResult(result);
        return response;
    }
}

We’ll create the web service using the Jersey ServletContainer in Tomcat. Once the web service is up and running, we can begin testing.

In order to test the web service, we will use the Karate tool. We start by creating a simple Karate feature file:

Feature: Calculator Service Test

Background:
    * url 'http://localhost:8080/ws/calculator'
    * configure ssl = true

Scenario: Test Adding Two Numbers
    Given def addNumbersRequest =
    """
    
        152
        42
    
    """
    And def expectedResponse =
    """
    
        194
    
    """
    When soap action 'addNumbers'
    And request addNumbersRequest
    Then match response == expectedResponse

The above example defines a single test, which ensures that the calculator web service correctly returns the sum of two numbers. This test first defines the payload to be sent to the service and the expected response. The payload is a simple XML file that mimics the SOAP payload sent by the client. The expected response is also an XML file containing the expected SOAP payload to be returned by the server. The test then submits the payload and verifies that the response received from the server matches the expected response.

Frequently Asked Questions about Karate Soap Testing Example

Karate is an open-source framework that is utilized for automation testing of web services. It is an API testing tool that can be used to test SOAP and REST services. Through this blog post, we will be discussing the questions that are frequently asked about karate soap testing example.

Q1. What is Soap Testing?

Soap Testing is a technique to test web services over the internet. It is a type of API testing that involves validating the SOAP (Simple Object Access Protocol) messages sent over HTTP/S. Through this testing, we can ensure that the web services are built as per the client’s requirements and are working efficiently with the expected output.

Q2. What is Karate Framework?

Karate is an open-source API testing tool that is designed to test web services. It supports both REST and SOAP web services testing. With the help of Karate, we can write test scenarios using the Gherkin language, which makes it human-readable. It uses a simple syntax, making it an easy-to-use tool for testing different types of services.

Q3. How can we perform Soap Testing using Karate?

To perform Soap Testing using Karate Framework, we first need to create a .feature file with test scenarios. We can define the test scenarios using the Gherkin language, which makes it human-readable. In the test scenario, we define the request and the expected response. After defining the test scenario, we run the test using the Karate Runner.

Q4. How to create a Soap Request using Karate?

To create a Soap Request using Karate, we first need to define the endpoint URL in the feature file. After that, we define the Request Header and Request Body. We can easily define the Request Body using the XML syntax in Karate. Here is an example of a Soap Request using Karate:

Scenario: Verify the GetCityForecastByZIP response

Given soap action ‚http://ws.cdyne.com/WeatherWS/GetCityForecastByZIP‘
And request
„““




90210



„““
When soap action is called
Then status 200
And match /Envelope/Body/GetCityForecastByZIPResponse/GetCityForecastByZIPResult/Success/text() contains true

Q5. How to execute Soap Request using Karate?

We can execute a Soap Request using Karate by running the Karate Runner. The Karate Runner reads the test scenario from the .feature file, executes the test, and generates the report with test results. We can use the below command to execute the tests using the Karate Runner:

java -jar karate.jar soap-test.feature

Q6. How to validate the Soap Response using Karate?

To validate the Soap Response using Karate, we can use the ‚match‘ keyword in the test scenario. With the help of the ‚match‘ keyword, we can match the expected response with the actual response. We can use the ‚contains‘ keyword to validate a specific value in the response. Below is an example of validating the Soap Response using Karate:

Then status 200
And match /Envelope/Body/GetCityForecastByZIPResponse/GetCityForecastByZIPResult/Success/text() contains true

Q7. Is Karate Framework easy to use for Soap Testing?

Yes, Karate is easy to use for Soap Testing because it has a simple syntax, and it supports the Gherkin language, making it human-readable. We can quickly write test scenarios using the Gherkin language, and the response validation is also easy with the help of the ‚match‘ keyword.

Q8. Can we test both REST and Soap Services using Karate?

Yes, we can test both REST and Soap Services using Karate Framework. We can write test scenarios using the Gherkin language for both services. Karate supports both REST and SOAP web services testing, making it an all-in-one testing tool for web services.

Karate Soap Testing Example

This guide will provide a step-by-step tutorial on how to use the Karate framework for testing, specifically for testing soap services. The guide assumes that you have a basic understanding of software testing, Java language, and the Soap web service.

Step 1: Installing Java, Maven, and Karate

After installing Java and Maven, open a command-line interface and type the following command:

„`
mvn archetype:generate -DarchetypeGroupId=com.intuit.karate -DarchetypeArtifactId=karate-archetype -DarchetypeVersion=2.0.0 -DgroupId=com.mycompany -DartifactId=myproject
„`

This command creates a new Maven project with the Karate dependencies included.

Step 2: Create Soap Service Test

Add the following code to the file:

„`
Feature:
Scenario:
Given request soapEnvelope(‚‚)
When soap action ‚‚
Then status 200
And match /Envelope/Body/YourDesiredElement == ‚‚
„`

This test checks if the soap service is running successfully by sending a request message and verifying that the response message has the expected values.

Replace the fields enclosed in „<>“ with your desired values.

Step 3: Running the Test

„`
mvn test -Dtest=soap-service
„`

This command runs the test using the Maven build system. Replace „soap-service“ by the name of the file you created earlier.

At the end of the test, the command-line interface displays the test results. If the test passes, the response status is 200, and the expected element value matches the actual element value.

Step 4: Understanding the Test Results

Conclusion

By following the steps outlined above, you can test your soap service efficiently and effectively, enabling you to ensure that your software is of the highest quality possible.