Skip to content

Test planning

These three skills turn an already-read source (a story, or a broad exploration request) into a concrete plan of what to test — either a step-by-step test plan, or a portfolio of exploratory charters selected based on the product's available context. None of the three runs tests: they only plan (area discovery, at most, does a surface-level inspection of the product to map it).


lippia-neo-create-test-plan

When to use it

When an already-analyzed user story needs an exhaustive test plan that covers all of its acceptance criteria (navigation flows + UI validation). It's triggered when someone asks to create a test plan from a story, or when you need to turn acceptance criteria into step-by-step scenarios. Besides the steps, it designs the data for each scenario: equivalence partitions and boundary values without repetition, negative and edge cases, reference data declared only once, derived data, and cases blocked by missing data (see Data-driven testing). It doesn't generate tests or run anything.

Invocation example
{
  "input": {
    "us_id": "PA-US-02",
    "user_story": {
      "summary": "As a user I want to apply a discount coupon in the cart"
    }
  }
}
Input Type Description
input.us_id Required short identifier of the story (it comes from lippia-neo-read-user-story); it names the output file.
input.user_story Required the already-read story (it assumes lippia-neo-read-user-story ran before).
input.app_urls Required it can be empty; if missing, it falls back to environment.base_url from qa-stack.yaml.
input.credentials Required it can include literal values extracted from the story, but the plan only references them by the name of the env_file variable, never by their value.
input.findings Optional findings from a previous exploratory run of the story (ui_selectors, executed_scenarios, findings). They complete the scenarios and, if they contradict the story on a piece of reference data, the findings prevail (and an open question is added).

Output

Field Description
test_plan the full test plan, in Markdown. It's saved to <paths.test_plans_dir>/<US-ID>-test-plan.md; if it already exists, it's never silently overwritten.
scenarios array of scenarios, each with id (e.g. TC-01), title, acceptance_criteria, scope (required / suggested), state (ready / blocked / needs_confirmation), state_reason, steps, expected_results, test_data (the list as is), and data_records (the typed data, see below).
test_data the data from the plan's "Datos de prueba" section, typed: reference_data (a domain with its records; an unknown value is left as null), variables (domain, environment variable, and usage), and partitions (input, criterion, partition, type, value, and scenario).
warnings warnings (missing data, conflicts between the story and the findings, etc.).

How it designs the data

What How it appears in the plan
Partitions and boundary values For each input, one partition per equivalence class and per boundary (mínimo (1), por encima del máximo…), with one value per partition and its type: válido, inválido, or borde. Never two values for the same partition
Negative and edge cases Always proposed for forms and text fields (empty, only one filled in, invalid, spaces, accents, special characters, maximum length). If they exceed the acceptance criterion, they go with **Alcance:** sugerido under "Casos sugeridos fuera de CA"
Reference data Declared only once per domain in "Datos de prueba", in a table whose first column is Dominio. Scenarios name them without copying values. They're never invented: a field that no source provides is left empty and generates an open question
Derived data As a reference to its origin (el stock del producto + 1), never the computed value
Credentials and identity data Only by the name of the environment variable (APP_USER, APP_USER_DISPLAY_NAME). An invalid credential for a negative case is described as a derivation (APP_PASSWORD con un carácter de más)
One behavior per scenario Variants that only change data are one scenario with several data items; a matrix, one scenario with one data item per combination

Each scenario has an attributes line with scope and state:

**Tipo:** Funcional · **Prioridad:** Alta · **Alcance:** CA · **Estado:** bloqueado — no hay un producto sin stock en el catálogo (ver pregunta abierta 4)
**Datos de prueba:**
- pendiente (ver pregunta abierta 4) — partición: sin stock — tipo: válido
**Estado:** in the plan state Meaning What happens next
(no state line) ready It has steps, expected results, and data It's explored, automated, and exported
bloqueado — <motivo> blocked It's missing a piece of data that no source provides It's automated marked as blocked (or not written, depending on the runner); it's not explored or exported
sin resultado esperado — <qué falta> needs_confirmation Some step has no known expected result (⚠️ sin resultado esperado) It's not automated or exported until someone confirms it

Each item in **Datos de prueba:** uses one of five forms, which are reflected in data_records[].source:

Form in the plan source
`teclado` — partición: coincide por nombre — tipo: válido literal
el stock del producto + 1 — partición: por encima del máximo — tipo: inválido derived
pendiente (ver pregunta abierta N) — … pending
referencia: precio del dominio `catalogo` reference
usuario: `APP_USER` variable

Any item can add — esperado: … with the expected result for that data item.

Chains with

Runs after lippia-neo-read-user-story (and optionally after lippia-neo-run-manual-testing, whose findings it can consume); its output feeds lippia-neo-generate-test-suite.


lippia-neo-discover-exploratory-areas

When to use it

When an exploratory testing request has a broad or incomplete scope, and you need to identify the real areas of the product that can be explored before creating charters. It combines the available documentation (stories), the existing test assets, and, when applicable, a live surface-level inspection of the target. Each area is backed by evidence; if the sources aren't enough, it blocks instead of making things up. It doesn't prioritize with a fixed risk model, doesn't run deep exploration, and doesn't report application defects.

Invocation example
{
  "input": {
    "request": "Explore the checkout and payments module"
  },
  "config": {
    "environment": { "base_url": "https://staging.miapp.com" },
    "paths": { "exploratory_dir": "exploration/" }
  }
}
Input Type Description
input.request Required the original exploration request.
config.paths.exploratory_dir Required directory where the discovery artifacts are saved (recommended default exploration/).
input.artifact_scope_id Optional if present, it's used as-is; if not, a new one is generated (EXP-<YYYYMMDD>-<HHMMSS>).
input.max_areas Optional limit on the number of areas to discover.
config.environment.base_url / config.environment.entry_point Optional entry point of the target for the live inspection; if it's missing, it doesn't block as long as there are other sufficient sources.
config.environment.app_version / config.environment.os Optional environment context.
config.paths.user_stories_storage.local_path Optional discovery source via local stories.
config.paths.test_plans_dir Optional discovery source via existing plans (it sets existing_test_coverage).
config.paths.env_file / config.auth Optional for the live inspection, if it requires authentication.

Output

Field Description
artifact_scope_id, discovery_path, discovery_markdown_path, target_context paths to portfolio/discovery.json and portfolio/discovery.md, plus the target context.
areas with area_id, name, description, entry_points, existing_test_coverage (none/partial/strong/unknown, informational only), evidence, source, notes.
areas_count, can_continue, blocking_reason none/insufficient_sources/target_unavailable/interaction_capability_unavailable/no_areas_discovered.
Chains with

Step 1 of lippia-neo-meta-run-exploratory-testing; its output (discovery) feeds lippia-neo-create-exploratory-charters.


lippia-neo-create-exploratory-charters

When to use it

When there's already an inventory of discovered areas (produced by lippia-neo-discover-exploratory-areas) and you need to turn it into a bounded portfolio of exploratory charters (SBTM). It doesn't apply a fixed risk scoring: it chooses and orders the areas based on the context actually available (the user's request, explicit priorities, known changes, existing coverage, etc.), without making up criticality, and it makes explicit the selection reason for each charter and why each unselected area was left out. It doesn't navigate the application or run tests.

Invocation example
{
  "input": {
    "discovery": { "areas": [{ "area_id": "AREA-01", "name": "Checkout" }] },
    "artifact_scope_id": "EXP-20260101-100000",
    "business_priorities": ["Checkout is critical for the release"]
  },
  "config": {
    "paths": { "exploratory_dir": "exploration/" }
  }
}
Input Type Description
input.discovery Required the area inventory produced by lippia-neo-discover-exploratory-areas.
input.artifact_scope_id Required functional scope of the artifacts to preserve.
config.paths.exploratory_dir Required directory where the portfolio and charters are written.
input.max_charters Optional defaults to 5.
input.time_box_minutes Optional defaults to 60 (valid range 15–90).
input.report_language Optional defaults to es.
input.selection_context / input.business_priorities / input.changed_areas / input.known_constraints Optional explicit context for selecting and ordering areas (priorities, recent changes, constraints); the user's instructions carry more weight than any internal heuristic.

Output

Field Description
artifact_scope_id, portfolio_manifest_path, portfolio_markdown_path paths to portfolio/portfolio.json and portfolio/portfolio.md.
charters CHARTER-001, CHARTER-002…, each with id, mission, area, exploration_focus, selection_reason, time_box_minutes, target_context, heuristics (optional), notes, charter_path.
areas_not_selected each area that was left out, with area and reason.
total_planned_minutes, can_continue
Chains with

Receives the discovery from lippia-neo-discover-exploratory-areas; its charters are consumed one by one in lippia-neo-run-exploratory-session. It's step 2 of lippia-neo-meta-run-exploratory-testing.