> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sedum.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# YAML test format

Tests can be written in TypeScript or YAML. [TypeScript tests](typescript-tests.md)
are the default and can run code between steps; this page describes YAML
tests, which are a list of sentences and need no code. Both formats run side by
side in one project.

A YAML test is one `*.test.yaml` file. Its path relative to the repository is its identity; use an optional `id` to keep that identity stable across renames. Use `description` for a human-readable title. You can omit `sedum`; it means format version 1. `sedum: 1` is also accepted.

```yaml theme={null}
description: a customer signs in
url: https://www.saucedemo.com/
data:
  user: standard_user
  password: $SAUCE_PASSWORD
steps:
  - type {{user}} in the username field
  - type {{password}} in the password field
  - click the login button
  - verify a list of products with prices is shown
```

Use either `steps` with at least one sentence, or a nonblank `goal` and required nonblank top-level `verify` claim. Do not combine the two modes. [Goal tests](goal-mode.md) use the same data bindings and CLI commands; their independent verification must pass before the test passes. Optional `before` and `after` lists use the same authored-step shape in either mode. A `use:` entry names a `*.module.yaml` file. `tags` is a list of strings and `meta` is a free-form mapping. `name`, `fileType`, and `run:` are not accepted.

## Reusable modules and hooks

A module contains only a required `parameters` list and a nonempty `steps` list. Parameters are unique required names with the same spelling rules as data keys. Calls supply every parameter once under `with` and cannot supply extra names. A module sentence sees its own parameters and its earlier remembered values; caller data is available only through an explicit `with` argument. Nested `use` calls receive the phase of their caller.

```yaml theme={null}
# modules/login.module.yaml
parameters: [username, password]
steps:
  - type {{username}} into the Username field
  - type {{password}} into the Password field
  - click the Login button
```

```yaml theme={null}
# login.test.yaml
url: https://example.test/login
data:
  username: alice
before:
  - use: ./modules/login.module.yaml
    with:
      username: "{{username}}"
      password: $LOGIN_PASSWORD
steps:
  - verify the products page is shown
after:
  - click the logout button
```

Module paths are relative to the file containing the `use` entry. Canonical targets must stay inside the repository. Nested modules are limited to 32 call edges; a cycle is an error. Missing files, invalid modules, cycles, depth overflow, and bad argument names fail validation before browser launch. A result's source stack runs from the test call site through nested module calls to the executed sentence.

`with` values accept strings, numbers, booleans, and null. Strings may interpolate caller `{{name}}` values and use `$VAR`, `${VAR}`, or `$$` for explicit environment access. A module occurrence evaluates its arguments when reached, so an earlier remembered value may be passed to a later call. An unavailable remembered value fails that call; an unset environment variable is an operational error. Environment-derived values and bindings made from them stay opaque in model requests and reports.

Navigation precedes `before`. A failed `before` skips `steps`; `after` still runs after an ordinary setup or body pass or failure while the page remains usable. Teardown continues through later entries after one fails. The first failure remains primary, and later teardown failures are retained separately. A teardown failure fails an otherwise passing attempt. External cancellation or a lost browser cannot guarantee cleanup.

The [local fixture flows](https://github.com/sedum-dev/sedum/tree/main/fixtures) show two tests sharing one UI login module. Signing in through an API or a saved session is not supported yet; use a UI login module.

`data` values can be strings, numbers, booleans, or null. Quote a value when its written characters matter, such as a postcode with a leading zero. `$VAR` and `${VAR}` read environment variables when that test runs; `$$` writes a literal dollar. They are not resolved while tests are discovered or checked for format errors. An unset variable therefore affects only a selected run. Environment-derived values are treated as secrets in displays and model requests.

Each sentence starts with one of these verbs. `click` and `type` act on a page element that Sedum locates. `verify` judges a claim and gates the test; `measure` (or `note`, `observe`) records the same scores without gating it. `remember ... as {{name}}` reads a value. The rest need no locator: `press Enter` (or `Tab`, `Escape`, an arrow key, `F1`–`F12`, a single character, or a quoted combination such as `press "Control+A"`), `wait 2 seconds` (at most 30 seconds), `scroll down` or `scroll up` (about one screen), and `goto https://example.com/path`, whose address may contain `{{name}}` values.

Some precise `verify` forms are deterministic and do not call the Judge. Double-quoted text checks exact, case-sensitive visible page text: `verify "Add debt" appears once`, `verify the text "Total" is not shown`, or `verify the text "A" or "B" is shown`. A count may be `once`, `twice`, or an exact number of times. `verify the page URL contains "/sign-up"` checks the current address. Placeholders inside the quotes are resolved before comparison. Unquoted `verify the text Welcome back is shown` can pass locally, case-insensitively, when that literal text is present; when it is absent, the Judge still decides because the wording may be a paraphrase. Claims about a heading, label, message, or other semantic role remain Judge claims unless they match a dedicated control-state form.

In a sentence, `{{name}}` refers to a `data` key or an earlier remembered binding, including inside a double-quoted literal. `remember the price shown as {{price}}` reads the selected page target's text (nonempty, at most 4096 characters); `remember the page text as {{name}}` reads the whole page. An earlier remembered value can be passed to a later module call and can appear in a Judge assertion. Environment-derived values remain placeholders in model input, even when an application echoes a credential into remembered page text. A remembered value is ordinary page text and stays readable in reports, unless it was read on a sensitive origin or contains an environment-derived secret; then it is redacted like one. A binding name cannot replace declared data or an earlier binding. A `type` step must name exactly one value; `type {{first}} then {{last}}` is an error. Format diagnostics show a file, line, column, and fix. A full offline validation also needs sentence classification and module checks; a format-only check does not claim those checks passed.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.