Metadata-Version: 2.4
Name: yatl-testing
Version: 0.1.4
Summary: Yet Another Testing Language
License-File: LICENSE
Keywords: testing,api,yaml,http,rest,declarative
Author: Khabib Shakhbanov
Requires-Python: >=3.14
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.14
Requires-Dist: jinja2 (>=3.1.6)
Requires-Dist: lxml (>=6.0.2)
Requires-Dist: pyyaml (>=6.0.3)
Requires-Dist: requests (>=2.32.5)
Project-URL: Documentation, https://github.com/Khabib73/YATL#readme
Project-URL: Homepage, https://github.com/Khabib73/YATL
Project-URL: Issues, https://github.com/Khabib73/YATL/issues
Project-URL: Repository, https://github.com/Khabib73/YATL
Description-Content-Type: text/markdown

# YATL — Yet Another Testing Language

[![Python](https://img.shields.io/badge/python-3.14+-blue.svg)](https://www.python.org/)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
[![GitHub stars](https://img.shields.io/github/stars/Khabib73/YATL?style=social)](https://github.com/Khabib73/YATL)

**YATL** is a declarative, YAML‑based testing language for API testing. If you know HTTP and YAML, you know YATL.

## Quick start

```bash
pip install yatl-testing
```

Create your first test file `ping.yatl.yaml`:

```yaml
name: ping
base_url: google.com

steps:
  - name: simple_test
    request:
      method: GET
    expect:
      status: 200
```

Run it:

```bash
yatl .
```

That’s it!

---

Consider another example, let's try to test a simple POST request:

We will use FastAPI to create a simple API:

```python
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str
    age: int

db = [
    User(name="John", age=30),
    User(name="Jane", age=25),
]

@app.post("/users", status_code=201)
def create_user(user: User):
    db.append(user)
    return {"status": "ok"}
```

Create a test file `users.yatl.yaml`:

```yaml
name: User API
base_url: https://localhost:8000

steps:
  - name: create_user
    description: Create a new user with name=John and age=30
    request:
      method: POST
      url: /users
      body:
        json:
          name: John
          age: 30
    expect:
      status: 201
      body:
        json:
          status: ok
```

Run it:

```bash
yatl .
```

That’s it!

## Why YATL?

Writing API tests in code is cumbersome. YATL turns tests into pure data — declarative, readable, and accessible to every team member.

### The Problem
- **You have to write code** – even for a simple GET request
- **High entry barrier** – need to know programming languages well
- **Complex dependencies** – chaining requests becomes spaghetti code
- **Hard to maintain** – tests become unreadable over time

### The Solution
YATL is a **domain‑specific language** that lets you describe API tests in clean YAML. No imperative code, no hidden magic.

> If you know HTTP and YAML, you know YATL.

## Key Features

- **Declarative syntax** – describe what to test, not how
- **Data extraction & templating** – use Jinja2 to reuse response data
- **Multiple data formats** – JSON, XML, form data, multipart files
- **Parallel execution** – run tests in parallel with `--workers`
- **Skip tests & steps** – disable tests without deleting them
- **Advanced validation** – validate with rules like `gt`, `regex`, `type`

## Example

```yaml
name: User API
base_url: https://api.example.com

steps:
  - name: login
    request:
      method: POST
      url: /auth/login
      body:
        json:
          username: "test"
          password: "secret"
    expect:
      status: 200
    extract:
      token: "response.access_token"

  - name: get_profile
    request:
      method: GET
      url: /profile
      headers:
        Authorization: "Bearer {{ token }}"
    expect:
      status: 200
```

## Usage

### Running Tests

```bash
# Run all `.yatl.yaml` files in a directory
yatl .


# Run with 5 parallel workers on `tests/` directory
yatl tests/ --workers 5
```

### Writing Tests

Every YATL test is a YAML file with a `.yatl.yaml` extension. The structure is simple:

```yaml
name: Test Suite Name
base_url: https://api.example.com

steps:
  - name: step_one
    request:
      method: GET
      url: /endpoint
    expect:
      status: 200
      body:
        json:
          field: "expected_value"
```

See the full documentation for all available options.

## Documentation

Full documentation is available in the [`docs/`](docs/) directory:
- [Usage Guide (English)](docs/usage.en.md)
- [Руководство по использованию (Russian)](docs/usage.ru.md)

## CI/CD Integration

YATL fits seamlessly into CI pipelines. Example GitHub Actions workflow:

```yaml
testing_api:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - name: Setup Python
      uses: actions/setup-python@v4
      with:
        python-version: 3.14

    - name: install yatl
      run: pip install yatl-testing

    - name: run tests
      run: yatl ./api_tests
```

---

> If you find this project useful, please [star it on GitHub](https://github.com/Khabib73/YATL). It really motivates me! ⭐️

