> For the complete documentation index, see [llms.txt](https://docs.precisiontestautomation.in/scriptlessautomation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.precisiontestautomation.in/scriptlessautomation/get-started/open-code-automation/api-automation.md).

# API Automation

### Introduction

This guide provides a step-by-step process to set up and run a Maven project with Scriptless Automation for API testing. It includes adding dependencies, configuring plugins, and setting up the necessary configurations for API automation.

### Prerequisites

Before you begin, ensure you have the following installed on your system:

* Java Development Kit (JDK)
* Apache Maven
* IntelliJ IDEA (or any preferred IDE)

### Project Setup

#### 1. Create a Maven Project

Create a new Maven project in your IDE or via the command line.

#### 2. Add Dependencies

Add the Scriptless Automation dependency for API testing to your `pom.xml` file:

```xml
<dependencies>
  <dependency>
    <groupId>in.precisiontestautomation.scriptlessautomation</groupId>
    <artifactId>scriptlessautomation-api</artifactId>
    <version>LATEST</version>
  </dependency>
</dependencies>
```

#### 3. Add Plugins

Add the following plugins to your `pom.xml` file to configure the execution of the main class and testing framework:

```xml
<plugins>
  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
      <execution>
        <goals>
          <goal>java</goal>
        </goals>
      </execution>
    </executions>
    <configuration>
      <mainClass>in.precisiontestautomation.runner.ScriptlessApplication</mainClass>
      <arguments>
        <argument>true</argument>
      </arguments>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M4</version>
    <configuration>
      <argLine>-XX:+ExplicitGInvokesConcurrent</argLine>
      <argLine>--add-opens java.base/java.lang.reflect=ALL-UNNAMED</argLine>
      <testFailureIgnore>false</testFailureIgnore>
      <suiteXmlFiles>
        <suiteXmlFile>target/testngenerator.xml</suiteXmlFile>
      </suiteXmlFiles>
    </configuration>
  </plugin>
</plugins>
```

### Configuration

#### 4. Add Scriptless Configuration

To execute Scriptless Automation for API testing, add the following configuration files in your project:

```plaintext
project
 └── config
     ├── reportConfiguration
     │   └── extentReportConfiguration.properties
     └── testNgConfiguration.properties
```

**4.1 reportConfiguration/extentReportConfiguration.properties**

This file contains the configuration settings for the Extent Reports.

```properties
# Extent Report Configuration
ReportName = AutomationReport

#DARK , STANDARD
Report_Theme = DARK
Report_JS = for (let e of document.querySelectorAll (".details-col")) { e.innerHTML ='Steps' };
Report_CSS = .header .vheader .nav-logo>a .logo {min-height: 52px;min-width: 52px;}
Report_logo = "/config/logo.jpg"
Report_captureScreenshotOnPass = true
```

**4.2 testNgConfiguration.properties**

This file contains the TestNG configuration settings.

```properties
# TestNG Configuration
ReportName = AutomationReport
Env = sandbox
ThreadCount= 2

FAILED_RETRY_COUNT=0
SET_TEST_SUITE_NAME = Scriptless
SET_TEST_NAME = Regression Testing

TEST_DATA_SECTIONS=All
TEST_IDS=All
DISABLE_TEST_IDS=

GROUPS=All
```

#### 5. Add Test Data

Add the necessary test data to your project. This involves creating a directory structure to store test data files and ensuring they are accessible to your test scripts. Use the following directory structure:

```plaintext
project
   └── test_data
       └── API
           ├── JsonRepository
           │   └── file.json
           ├── test_case_flows
           │   └── TestDirectory
           │       └── TestID_GroupName.csv
           └── schemaJson
               └── schema.json        
```

**5.1 test\_data/API/JsonRepository/**

This file contains the JSON payloads for your API tests.

```json
{
  "exampleKey": "exampleValue"
}
```

**5.2 test\_data/API/test\_case\_flows/TestDirectory/**

This file contains test case flows and steps for each test. Each directory under `test_case_flows` represents a feature.

```csv
# Example test case flow
DEPENDANT_TEST_CASE,NONE,
END_POINT,https://api-generator.retool.com/vEQvcT/data,
METHOD,POST,
PARAMS:KEY,NONE,
PARAMS:VALUE,NONE,
AUTH:KEY,NONE,
AUTH:VALUE,NONE,
HEADERS:KEY,Content-Type,
HEADERS:VALUE,application/json,
BODY:KEY,JsonRepository,name
BODY:VALUE,test,Custom:CustomClass:body
RESPONSE:CODE,201,
RESPONSE:SCHEMA,putSchema.json
RESPONSE:JSON_PATH,'Column 1',id
RESPONSE:EXPECTED_VALUE,ApiGlobalVariables:name,NONE
RESPONSE:STORE_VALUE,Name,ID
```

**5.3 test\_data/API/test\_case\_flows/schemaJson/**

This file performs schema validation against the response generated by the API request

```
{
  "Column 1": "ApiGlobalVariables:name",
  "id": "@Integer"
}
```

### IntelliJ IDEA Setup

#### 6. Add IntelliJ Run Configuration

Create a run configuration in IntelliJ IDEA to run your Maven project. Follow these steps:

1. Go to `Run > Edit Configurations`.

   <figure><img src="/files/gyiOCKh6NUuXrBE03g0L" alt=""><figcaption></figcaption></figure>
2. Click on the `+` icon and select `Application`.

   <figure><img src="/files/wuXwOPkgQ2ihzaaSfY1U" alt=""><figcaption></figcaption></figure>
3. Set the name for your configuration (e.g., `runner`).

   <figure><img src="/files/DvFpaYm9MUfL218SMilU" alt=""><figcaption></figcaption></figure>
4. Click on Apply

#### 7. Run CLI Command

To execute the project, use the following CLI command:

```bash
mvn clean exec:java test
```

This command will run the main class defined in the `exec-maven-plugin` configuration.

### Conclusion

By following this guide, you have set up a Maven project with Scriptless Automation for API testing. You configured the necessary dependencies, plugins, and run configurations to execute your API automation tests.

### Next Steps

* Customize your test scripts according to your API requirements.
* Explore more features of Scriptless Automation to enhance your test coverage.
* Integrate additional tools and frameworks as needed for comprehensive test automation.