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

# Adding dependency

To use Gradle, we have to add the dependencies below to our project's build file: 

## Gradle (in `build.gradle`)

```
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath "io.qameta.allure:allure-gradle:2.8.1"
    }
}

plugins {
    id 'io.qameta.allure'
}

allure {
    version = '2.13.1'
    autoconfigure = true
    aspectjweaver = true
    clean = true
    allureJavaVersion = "${allure.version}"
    resultsDir = file('test-output/allure-results')
    reportDir = file('test-output/allure-reports')
   downloadLink = "https://repo.maven.apache.org/maven2/io/qameta/allure/allure-commandline/${allure.version}/allure-commandline-${allure.version}.zip"
}
```

**Opening Allure report**

To open the Allure report after test execution using Gradle, we can use the following command:

```
./gradlew allureServe
```

## Maven (in `pom.xml`)

```xml
<properties>
    <aspectj.version>1.9.5</aspectj.version>
</properties>

<dependencies>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-testng</artifactId>
        <version>2.13.1</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
            <configuration>
                <testFailureIgnore>false</testFailureIgnore>
                <argLine>
                    -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
                </argLine>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.aspectj</groupId>
                    <artifactId>aspectjweaver</artifactId>
                    <version>${aspectj.version}</version>
                </dependency>
            </dependencies>
        </plugin>
        <plugin>
            <groupId>io.qameta.allure</groupId>
            <artifactId>allure-maven</artifactId>
            <version>2.10.0</version>
            <configuration>
                <reportVersion>2.13.1</reportVersion>
            </configuration>
        </plugin>
    </plugins>
</build>
```

**Opening Allure report**

To open the Allure report after test execution using Maven, we can use the following command:

```
mvn allure:serve
```


# Allure annotations

Allure has few annotations for marking the life cycle of test execution.
* `@Step`
* `@Attachment`


## `@Step`
Any action that constitutes a testing scenario is marked with `@Step`.

```
@Step("send request")
public void sendRequest(String url) {
    ....
}
```

Here, the name of the step will be taken by default if the name parameter is not mentioned in `@Step`. We can also have placeholders in the name parameter. For more information, please follow this [link](https://docs.qameta.io/allure/#_steps_3).

This can also be done programmatically, using the code below:

```
import static io.qameta.allure.util.AspectUtils.getName;
import static io.qameta.allure.util.AspectUtils.getParameters;
import static io.qameta.allure.util.ResultsUtils.getStatus;
import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
import io.qameta.allure.AllureLifecycle;
import io.qameta.allure.Step;
import io.qameta.allure.model.Parameter;
import io.qameta.allure.model.Status;
import io.qameta.allure.model.StepResult;
import io.qameta.allure.Allure;

public void sendRequest() {
    
    StepResult result = new StepResult().setName("send request");
    Allure.getLifecycle().startStep(UUID.randomUUID().toString(), result);
    try {
        ...
        ...
        getLifecycle().updateStep(s -> s.setStatus(getStatus(e).orElse(Status.PASSED));
    } catch(Exception e) {
        getLifecycle().updateStep(s -> s.setStatus(getStatus(e).orElse(Status.BROKEN));
        throw e;
    }
    
}
```

## `@Attachment`

The method below annotated with `@Attachment` should return either a `String` or `byte[]`. For attaching a file to the report, do as follows:

```
@Attachment(value = "adding log", type = "text/plain")
public String addAttachment() {
    return "hello";
}
```

Alternatively, for doing the same programmatically without using  `@Attachment` annotation, do as follows:

```
public void sendRequest() {
    ...........
    Allure.getLifecycle().addAttachment("adding log", "text/plain", ".txt", "hello");
    
}
```
Multiple overloaded methods are also available. Please follow this [link](https://docs.qameta.io/allure/#_attachments_3) for more information.


Additionally, please follow this [link](https://docs.qameta.io/allure/#_testng) for more comprehensive information about the Allure framework.

In this lesson, you'll learn about Allure's dependencies and annotations.

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

Allure Dependency and Annotations

Adding dependency

Gradle (in `build.gradle`)

Allure Dependency and Annotations

Adding dependency

Gradle (in build.gradle)

Gradle (in `build.gradle`)