AI driven testing in action - data driven testing

Scalable Data-Driven Testing with Functional ATS

Functional decomposition + decoupled data = scalable automation

This demo shows how Agilitest enables true data-driven testing by combining:
• Functional decomposition (a reusable subscript that fills the form)
• Full separation between logic and data (external CSV file)
• Deterministic ATS execution without AI dependency
‍
The Objective

Instead of generating one large automation script, we design:
✅ A functional subscript responsible only for filling the form
✅ A parent script that iterates over a dataset
✅ A separate CSV file containing multiple test profiles

This creates:
• Reusability
• Scalability
• Clean architecture
• Maintainability
• And most importantly:The final automation is pure ATS — no AI required to execute it.
‍
AI generates the script.
ATS guarantees its execution.

Step 1 — Defining the Data-Driven Intent

Claude receives instructions to create a data-driven test scenario with multiple profiles.
‍
The objective is to validate several combinations of:
• Roles
• Pass types
• Themes
• Experience levels
• Budget slider
• Optional fields

Instead of duplicating logic, we will factorize behavior.

Step 2 — Identifying Form Elements

Using the REPL, Claude identifies all interactive components:
• Text inputs
• Select fields
• Checkboxes
• Radio buttons
• Slider
• Toggles
• Submit button

This ensures we build a reliable functional subscript.

Step 3 — First Functional Entry

A first profile is entered interactively to validate:
• Correct selectors
• Expected behavior
• Budget slider value control

This validates the functional flow before generalizing it.

Step 4 — Graphical Slider vs Real Value

Although the slider is graphical, ATS retrieves the real numeric value for assertion.
This guarantees:
• Visual interaction
• Functional verification
• Deterministic validation

We validate actual business values — not pixels.

Step 5 — Second Profile Validation

A second profile is tested to confirm:
• Different role
• Different pass
• Different budget
• Optional fields left empty

This ensures the flow supports variable data.

Step 6 — Creating the Functional Subscript and Data File

Claude generates:
A reusable subscript:

remplirInscription.ats
‍

A CSV file:

inscriptions.csv

‍

The subscript contains only the functional logic to fill the form.
The CSV contains only data.

This is the core principle: Logic ≠ Data

Step 7 — Parent Script Orchestration

The parent script:
• Opens the browser
• Calls the subscript
• Passes each row of the CSV
• Closes the channel

This creates a clean layered architecture:
Parent script → Functional subscript → Data file

Step 8 — Generated Data File

The CSV contains multiple varied profiles:
• Students
• Developers
• Senior profiles
• Different budgets
• Optional fields populated or empty

The test coverage is driven by data variation — not script duplication.

Step 9 — Conditional Logic in the Subscript

The subscript includes conditions such as:

IfNotEmpty($param(phone)) → enter value

This ensures:
• Optional fields are handled properly
• Empty CSV values do not break the flow
• The script remains generic and reusable

Step 10 — Compiled ATS Execution

The REPL is closed.
The test is compiled and executed in standard ATS mode.
At this stage:
• No AI is required
• No Claude runtime is involved
• The script runs in CI/CD normally

The result is a pure functional ATS data-driven test.

What This Demonstrates

This demo demonstrates three critical principles:
1. Functional Decomposition
A reusable subscript encapsulates business behavior:
Fill the form
Handle optional values
Validate the budget

2. Data Decoupling
The CSV is fully independent:
Test scenarios evolve without touching the logic
New cases are added by editing data only
Non-technical users can modify test coverage

3. Deterministic Execution
The final artifact is:
Human-readable ATS
Versionable in Git
Executable in CI/CD
Independent from AI

AI accelerates the creation phase.
ATS guarantees execution stability.