Gain insights into performing REST and SOAP API test automation, writing API and integration tests from scratch, and preparing for test automation interviews with a downloadable framework.

restassured.tar.gz

TestNG

Java

TestNG-1

TestNG-2

TestNG-3

TestNG-4

IntegrationTest

IntegrationTest2

TestNG SOAP

In software development, microservices and APIs are used for writing business logic. API testing has become an important component in the testing cycle, as it can be used to test the functionality, integration flows, load and performance.

In this course, you will learn how to perform REST and SOAP API test automation. This course covers all the required details for you to start writing API and integration tests from scratch. It will also prepare you for test automation interviews.

As part of the course, you will be able to download a sample API automation framework. You can use this for writing automation tests of modules or applications, or just extend and customize it for your own use

Learn REST and SOAP API Test Automation in Java

# Creating `BaseTest` class

Since we use the `Spring` framework and `Annotations` for defining beans, we need to load them before doing anything. Here, we will use the `TestNG` annotation `@BeforeSuite` to load the beans using `AnnotationConfigApplicationContext` which reads all the `Spring` annotated classes like `@Configuration`, `@Service`, etc. 

In our case, we have annotated the `WebServiceClient` class with `@Configuration` for the bean that needs to be loaded.

We will create `BaseTest` which will be extended by all the test classes so that we need not duplicate the `@BeforeSuite` method that contains loading of beans. This will be executed once per test suite and initializing the `WebServiceTemplate` in `@BeforeClass` will be executed for every test class that is extending `BaseTest`. We will mark `BaseTest` as `abstract` to disallow the explicit initialization of the class.

It also has the `SERVICE_URL` that holds the location where the web service is hosted.

```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.ws.client.core.WebServiceTemplate;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeSuite;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

public abstract class BaseTest {

	protected static ApplicationContext CONTEXT;

	protected WebServiceTemplate webServiceTemplate;

	protected static final String SERVICE_URL = "http://ezifyautomationlabs.com:6566/educative-soap/ws";

	protected static final Logger LOG = LoggerFactory.getLogger(BaseTest.class);

	@BeforeSuite
	public void init() {
		if (CONTEXT == null) {
			CONTEXT = new AnnotationConfigApplicationContext(io.educative.soap.WebServiceClient.class);
		}
	}

	@BeforeClass
	public void initTemplate() {
		webServiceTemplate = CONTEXT.getBean(WebServiceTemplate.class);
	}

	protected void printResponse(Object response) {
		try {
			LOG.info("printing response '{}' => \n{}", response.getClass().getName(),
					new XmlMapper().writerWithDefaultPrettyPrinter().writeValueAsString(response));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
```


To learn more about `TestNG` annotations, please follow this [link](https://testng.org/doc/documentation-main.html#annotations).

# Creating `TestClass`

Here, we are creating a test class to test the `GetStudents` API. All the initialization code is already contained in `BaseTest` and marked with `TestNG` configuration annotations. Now, we have the required things to make the web service call.

To make the web service call, we need to know the service URL (where the web service is hosted), the request format (or class), and the response format (or class). All these information can be found in `students.wsdl`.

After building the test project, all the request and response formats (or classes) mentioned in `students.wsdl` will be generated and available for us to use. 

In this lesson, we will learn how to send requests and receive responses using the SOAP client that we created in the previous lesson. We will also learn how to validate the response.

About API and WebServices

Introduction to HTTP

Introduction to REST API

REST API Automation using Rest Assured

Introduction to SOAP API

SOAP API Automation

Integration Test

Allure Reporting

Manual Testing: REST and SOAP API

Bonus: API Test Automation Framework

Conclusion

Sending Requests using SOAP Client

Creating `BaseTest` class

Sending Requests using SOAP Client

Creating BaseTest class

Creating `BaseTest` class