README.md

# AutoRestTest

### Introduction
***AutoRestTest*** is a complete testing software for automated API testing that combines the utility of graph
theory, Large Language Models (LLMs), and multi-agent reinforcement learning (MARL) to parse the OpenAPI Specification
and create enhanced comprehensive test cases. AutoRestTest specifically supports **OpenAPI Specification 3.0**.

Watch this [demonstration video](https://www.youtube.com/watch?v=VVus2W8rap8) of AutoRestTest to learn how it solves complex challenges in automated REST API testing, as well as its configuration, execution steps, and output.

> [!NOTE]
> Following the release of the demonstration video, the code base has been refactored.
> Refer to this `README.md` for the most current setup and execution details.

<p align="center">
  <a href="https://www.youtube.com/watch?v=VVus2W8rap8">
    <img src="https://img.youtube.com/vi/VVus2W8rap8/0.jpg" alt="Watch the video">
  </a>
</p>

The program uses LLMs for natural-language processing during the creation of the reinforcement
learning tables and graph edges. AutoRestTest supports any LLM from an OpenAI-API compatible provider, including OpenAI, OpenRouter, Azure OpenAI, and local models (LocalAI, LM Studio, vLLM, Ollama, etc.).

> [!Important]
> An API key from your chosen LLM provider is required. The cost per execution depends on your provider and model choice.
> For reference, when testing an average API with ~15 operations using GPT-4o-mini, the cost was approximately $0.1.

## Terminal User Interface (TUI)

AutoRestTest features a modern, interactive terminal user interface built with [Rich](https://github.com/Textualize/rich) that provides:

### Interactive Configuration Wizard

On startup, AutoRestTest launches an interactive configuration wizard that allows you to:
- **Select API specifications** from discovered files or enter custom paths
- **Choose LLM providers** (OpenAI, OpenRouter, Local) with pre-configured model options
- **Configure test duration** with convenient presets (5, 10, 20, 30, 60 minutes)
- **Adjust Q-learning parameters** (learning rate, discount factor, exploration)
- **Toggle caching options** for faster repeated runs
- **Override API URLs** for local testing

The wizard uses sensible defaults from `configurations.toml`, so you can simply press Enter to accept defaults or customize any setting.

### Live Execution Dashboard

During request generation, a real-time dashboard displays:

```
╔══════════════════════════════════════════════════════════════════════════════╗
║ [STATUS] Request Generation                                                   ║
╠══════════════════════════════════════════════════════════════════════════════╣
║  ┌──────────────────────────────────────────────────────────────────────┐    ║
║  │ Time Elapsed: 00:15:32            Time Remaining: 00:04:28           │    ║
║  │ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 77.8%    │    ║
║  └──────────────────────────────────────────────────────────────────────┘    ║
║                                                                               ║
║  Successfully Processed (2xx) Operations:          1,482                     ║
║  Operation Coverage:                               85.2%                     ║
║  Unique Server Errors (5xx):                       7                         ║
║  Total Requests Sent:                              3,847                     ║
║                                                                               ║
║  Status Code Distribution                                                     ║
║  ┌──────────────────────────────────────────────────────────────────────┐    ║
║  │ 200: ████████████████████████████████████████████░░░░░░░░  1,482    │    ║
║  │ 404: ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    150    │    ║
║  │ 500: █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░      7    │    ║
║  └──────────────────────────────────────────────────────────────────────┘    ║
║                                                                               ║
║  Current Operation: GET /api/users/{id}                                       ║
║                                                                               ║
║  [COST] Total LLM usage: $0.11 USD                                           ║
╚══════════════════════════════════════════════════════════════════════════════╝
```

Features include:
- **Real-time progress tracking** with elapsed and remaining time
- **Color-coded status codes** (green for 2xx, orange for 4xx, red for 5xx)
- **Visual progress bars** for status code distribution
- **Live cost estimation** based on token usage
- **Current operation indicator** showing what's being tested
- **Mutation counter** tracking the number of fuzzing mutations applied

### Q-Table Initialization Progress

During the Q-table initialization phase, the Value Agent and Header Agent (if enabled) perform LLM calls to generate test values for each API operation. A live progress display shows:

```
╭──── ⚙ Value Agent Q-Table Generation ────╮
│                                           │
│   ━━━━━━━━━━━━━━━━━━━━━━━───────  67.5%  │
│                                           │
│   Operations: 27/40  │  Elapsed: 03:45   │
│                                           │
│   ▶ POST /api/users                       │
│                                           │
╰───────────────────────────────────────────╯
```

This progress display appears for both Value Agent and Header Agent initialization, showing:
- Visual progress bar with percentage complete
- Operation count (completed/total)
- Elapsed time
- Current operation being processed

### TUI Command Line Options

| Option | Description |
|--------|-------------|
| `--skip-wizard` | Skip configuration wizard, use `configurations.toml` directly |
| `--quick` | Quick setup wizard (essential settings only) |
| `-s, --spec PATH` | Override specification path |
| `-t, --time SECONDS` | Override test duration |
| `--width N` | Set TUI display width (default: 100) |

**Examples:**

```bash
# Full interactive mode (default)
poetry run autoresttest

# Quick setup - only essential settings
poetry run autoresttest --quick

# Skip wizard entirely, use config file
poetry run autoresttest --skip-wizard

# Override spec and duration via CLI
poetry run autoresttest -s specs/original/oas/spotify.yaml -t 600
```

## Installation

We recommend using Poetry with `pyproject.toml` for dependency management and scripts. A `poetry.lock` file pins exact versions.

Steps:
1. Clone the repository.
2. Ensure Python 3.10.x is available (project targets `>=3.10,<3.11`).
3. Install dependencies with Poetry (uses `poetry.lock` if present):
   - `poetry install`
4. Create a `.env` file in the project root and add:
   - `API_KEY='<YOUR_API_KEY>'`

Alternatives (provided but not recommended):
- `pip install -r requirements.txt`
- `conda env create -f autoresttest.yaml`

Optionally, if the user wants to test specific APIs, they can install their OpenAPI Specification files within a folder
in the root directory. For convenience, we have provided a large array of OpenAPI Specifications for popular and 
widely-used APIs. These Specifications can be seen in the `aratrl-openapi` and `specs` directories.

### Running Local Services

AutoRestTest includes support for running local REST API services for testing. Some services require building before use:

#### JDK 8_1 Services (features-service, ncs, scs)

These services must be built before first use:

```bash
# Make the build script executable
chmod +x services/build_jdk8_1_services.sh

# Build all JDK 8_1 services
bash services/build_jdk8_1_services.sh
```

After building, start a service:
```bash
cd services
python3 run_service_mac.py features-service no_token
```

For detailed instructions, see `FEATURES_SERVICE_SETUP.md`.

#### Other Supported Services

Other services like genome-nexus, language-tool, youtube, etc. can be run without building:
```bash
cd services
python3 run_service_mac.py <service-name> <token>
```

See `services/README.md` for the full list of supported services.

At this point, the installation step is complete and the software can be executed. However, it is important that the
following configuration steps are completed for purposeful execution.

## Configuration

There is a wide array of configuration options available within the codebase. All configuration options are easily accessible via a single TOML file at the project root: `configurations.toml`.

Below are the relevant settings and where to find them in `configurations.toml`.

#### 1. Specifying the API Specification

If you intend to use your own OpenAPI Specification file as described in the Installation section, set the relative path (from the project root) to that file in `configurations.toml` under `[spec].location`.

Only `.yaml` and `.json` files are supported (OpenAPI 3.0). Example: `aratrl-openapi/market2.yaml`.

Specification parsing is handled by [Prance](https://github.com/jfinkhaeuser/prance). If your spec has circular/self-referencing `$ref` chains, you can tune the resolver behavior with:
- `[spec].recursion_limit` (default: `1`) — the maximum number of times a circular reference may appear in the resolution stack before a placeholder schema is substituted; a value of 1 means a self-referencing element is resolved once before being replaced.
- `[spec].strict_validation` (default: `true`) — when `true`, the OpenAPI spec is strictly validated and parsing stops on errors; when `false`, invalid sections are skipped where possible so execution can continue.

#### 2. Configuring Reinforcement Learning Parameters

Configure Q-learning parameters in `configurations.toml`:
- `[q_learning].learning_rate` (default: `0.1`)
- `[q_learning].discount_factor` (default: `0.9`)
- `[q_learning].max_exploration` (epsilon; default: `1`, decays over time to `0.1`)

Instead of limiting episodes, the program limits RL iterations using a time budget. Set the duration (in seconds) under:
- `[request_generation].time_duration` (default: `1200`)

> [!NOTE]
> This time budget applies only to the MARL (Q-learning) phase. The initial value table generation phase, which runs before Q-learning begins, is not time-limited and will process all operations in the specification.

#### Parameter Combination Sampling

For APIs with many parameters, generating all possible combinations would cause memory exhaustion. AutoRestTest uses depth-weighted stratified sampling to bound combinations while prioritizing smaller (more diagnostic) combinations. Configure under `[agent]`:

| Option | Default | Description |
|--------|---------|-------------|
| `max_combinations` | `12` | Maximum optional parameters per combination. Required parameters are always included. |
| `max_total_combinations` | `3000` | Hard cap on combinations per operation. Smaller combinations are kept when truncating. |
| `base_samples_per_size` | `200` | Sample count at size=1; decays for larger sizes (e.g., size=5 gets ~60 samples). |
| `combination_seed` | `42` | Seed for reproducible random sampling. Change for different samples. |

Example distribution for an operation with 30 parameters:
- Size 1-2: All combinations enumerated (30 + 435 = 465)
- Size 3-12: Random samples (~700 total)
- Total: ~1,200 unique combinations (well under 3K cap)

> [!TIP]
> The above steps alter the variables across all agents used within the software. If the user desires to change
> the individual agent parameters, they can navigate to the `src/autoresttest/agents` files and change the parameters.

#### 3. Parallel Value Table Generation

The Value Agent's Q-table initialization can be parallelized using a thread pool, which significantly speeds up startup for APIs with many operations. Configure this under `[agent.value]`:
- `[agent.value].parallelize` (default: `true`) — when `true`, operations are processed concurrently using a thread pool; when `false`, the original sequential depth-first traversal is used.
- `[agent.value].max_workers` (default: `4`) — number of worker threads for parallel generation (ignored if `parallelize` is `false`). Set to match your CPU core count for optimal performance.

> [!NOTE]
> Rate-limited responses (HTTP 429) are automatically retried with exponential backoff.

#### 4. Configuring the LLM

AutoRestTest supports any LLM from an OpenAI-API compatible provider. Configure the model and provider in `configurations.toml`:

| Option | Default | Description |
|--------|---------|-------------|
| `[llm].engine` | `gpt-4o-mini` | Model identifier. Format depends on provider (e.g., `gpt-4o-mini`, `google/gemini-2.0-flash-001`, `anthropic/claude-3-haiku`). |
| `[llm].api_base` | `https://api.openai.com/v1` | API endpoint URL. Change for alternative providers. |
| `[llm].creative_temperature` | `1` | Temperature for creative parameter generation. |
| `[llm].strict_temperature` | `1` | Temperature for repair or deterministic flows. |
| `[llm].max_tokens` | `30000` | Maximum tokens for LLM response. Set to `-1` to omit and use provider default. |

**Example configurations:**

```toml
# OpenAI (default)
[llm]
engine = "gpt-4o-mini"
api_base = "https://api.openai.com/v1"

# OpenRouter (access to many models)
[llm]
engine = "google/gemini-2.0-flash-001"
api_base = "https://openrouter.ai/api/v1"

# Local model (LM Studio, Ollama, etc.)
[llm]
engine = "local-model"
api_base = "http://localhost:1234/v1"
```

> [!WARNING]
> The model must support **JSON mode**. Most recent models from major providers support this feature.
> The console output will list token usage for analyzing costs, if supplied by the provider.

#### 5. Use of Cached Graphs and Reinforcement Learning Tables

The software can cache the graph and Q-tables to reduce cost and speed up repeated runs. Configure this behavior under:
- `[cache].use_cached_graph` (default: `true`)
- `[cache].use_cached_table` (default: `true`)

> [!IMPORTANT]
> The cache parameter structure changed on Dec. 10, 2025. Recreate caches (clear `cache/` contents) so they remain compatible with newer runs.

> [!NOTE]
> When enabled, these options store and read cached data under the `cache/` directory at the project root (for example, `cache/graphs/` and `cache/q_tables/`).
> If disk usage becomes a concern, you can delete the cached project information in `cache/` after use; the data will be regenerated on the next run when needed.

#### 6. Optional Header Agent

AutoRestTest contains an optional Header agent responsible for testing the API with different authentication headers. Due to difficulties 
of different authentication flows, the Header agent is only able to use Basic Authentication. By default, the agent is disabled.

Toggle via `configurations.toml`:
- `[agents.header].enabled` (default: `false`)

> [!CAUTION]
> The Header agent Q-table should be rerun when executing services with local databases that refresh, as the user
> credentials may become invalid.

#### 7. Custom Static Headers

For APIs that require custom headers (such as API keys or Bearer tokens), you can configure static headers in the `[custom_headers]` section. These headers are included with every request.

```toml
[custom_headers]
X-API-Key = "your-static-key"
Authorization = "Bearer ${ACCESS_TOKEN}"
```

Environment variable interpolation is supported using the `${VAR_NAME}` syntax. Store sensitive values in your `.env` file:
```
ACCESS_TOKEN=your_bearer_token
```

> [!CAUTION]
> If you enable the Header Agent (`[agents.header].enabled = true`) alongside custom headers, be aware that the Header Agent may override your `Authorization` header during testing. The Header Agent uses Basic Authentication tokens and has higher priority than custom static headers. For Bearer token or API key authentication, keep the Header Agent disabled.

#### 8. Custom API URL Override

By default, AutoRestTest extracts the API base URL from the `servers` field in your OpenAPI specification. If you need to target a different host (e.g., a local development server or staging environment), you can override this behavior in the `[api]` section:

```toml
[api]
override_url = true
host = "localhost"
port = 8080
```

When `override_url` is set to `true`, the tool constructs the API URL as `http://{host}:{port}/` instead of using the specification's server URL.

| Option | Default | Description |
|--------|---------|-------------|
| `override_url` | `false` | When `false`, uses the URL from the OpenAPI spec. When `true`, uses the custom host and port. |
| `host` | `localhost` | The hostname for the custom API URL. |
| `port` | `8080` | The port number for the custom API URL. |

> [!TIP]
> This is useful when testing local services that run on a different port than specified in the OpenAPI spec, or when the spec contains a production URL but you want to test against a local or staging environment.

## Execution

Run the script using Poetry, after following the installation instructions:
```
poetry run autoresttest
```

To indicate the specification for execution, set `[spec].location` in `configurations.toml`. This path must be relative to the project root.

### Docker Execution

For ease of use, the software can be executed using Docker. The user can apply the following commands from the 
root directory sequentially to execute AutoRestTest using the pre-built Docker image:

```
docker build -t autoresttest .
docker run -it autoresttest
```

Ensure that `configurations.toml` is configured correctly before executing the software.

## Results

Throughout AutoRestTest's execution, the TUI provides real-time visual feedback including:
- **Phase indicators** showing current execution stage (Graph Construction, Q-Table Initialization, Request Generation)
- **Live dashboard** during request generation with time tracking, status code distribution, and cost estimation
- **Final report** with summary statistics, success rates, and token usage
- **Smart status code grouping** - automatically groups by category (2xx, 4xx, 5xx) when there are many different codes
- **Color-coded time indicators** - remaining time changes color based on percentage remaining (red < 5%, yellow < 20%) 

#### Report Generation and Data Files

AutoRestTest will generate a series of files in the `data` directory within the root folder for easy access to execution results. 
The following are the files generated:
- `report.json`: Contains the compiled report of the API testing process, including key summary statistics and information.
- `operation_status_codes.json`: Contains the distribution of status codes for each operation.
- `q_tables.json`: Contains the completed Q-tables for each agent.
- `server_errors.json`: Contains the unique server errors encountered during the testing process. Only JSON-seriable errors are stored.
- `successful_parameters.json`: Contains the successful parameters for each operation.
- `successful_responses.json`: Contains the successful responses for each operation.
- `successful_bodies.json`: Contains the successful object request bodies for each operation.
- `successful_primitives.json`: Contains the successful primitive request bodies for each operation.

These files contain the necessary information for analysis into the success of AutoRestTest. 

> [!NOTE]
> The output files can grow in size according to the number of operations and the duration of execution. 
> For example, the file containing successful responses can grow to be several **gigabytes** when executing for a long duration. 
> It is recommended to clear the `data` directory when the files are no longer needed.