create-test-cases · v0.5.0 · 2026-10-20 · sha256 3ec12d508608c194
create-test-cases v0.5.0A
Immutable. This exact content never changes and is served at /api/v1/blob/3ec12d508608c194.
No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_cwqwodhe6zjojd3u/3ec12d508608c1940c221e9e6159d0c84d79eabd3cccc95d8f428def25948fcc.json
Then /plugin install create-test-cases@markdownregistry-cwqwodhe6zjojd3u in Claude Code. It installs this exact version, the one graded A here, pinned to the commit it was graded at, and leaves it there.
---
name: create-test-cases
description: Designs manual test cases from a synced requirement key such as CEL-6, a pasted requirement, or captured TrueTest sessions. Then creates, updates, and links them in Katalon True Platform (formerly TestOps) after a coverage and duplicate check. Use when a written requirement or real user behavior exists and cases do not. Not for unscripted exploration (exploratory-charter) or inventory cleanup (test-management). For the manual tester.
license: MIT
compatibility: Requires the Katalon True Platform MCP server and network access.
metadata:
version: "0.5.0"
mcp-contract: "katalon-docs-2026-10"
---
# Katalon Create Test Cases
This skill covers test design and import: read a requirement, design cases, check what exists, then create, update, and link. The `true-platform-testing` skill routes end-to-end requests here. Tool names below are bare. Clients add a prefix (Claude Code: `mcp__<server>__<tool>`).
## What the MCP can and cannot do
- **Can:** list projects and repositories, find and read requirements, search the Knowledge Base (`search`), find/read/create/update/move/duplicate test cases, manage folders and suites, read suite collections, link and unlink requirements (`manage_requirement_test_case_linkages`), read the team's saved conventions (`memory_list`, `memory_read`), and generate cases from TrueTest sessions or journey-map flows.
- **Cannot:** create requirements (they sync from Jira or Azure DevOps), create a formal Test Plan entity, or inspect the live application.
- **Test plan workaround:** create or reuse a named folder and suite as the executable planning structure.
Read `references/capability-boundaries.md` when the user asks whether the platform can do one specific operation.
## Resolve context first
Before any write:
1. Call `list_projects`, then `list_repositories`.
2. Treat repository and Test Project as one target.
3. If exactly one repository exists, use it. If several are equally likely, ask the user to choose.
4. If the user says "Katalon Cloud" or "cloud repo", prefer a repository named `Katalon Cloud`.
5. Do not scan every repository to avoid asking.
6. Call `memory_list` once. It returns the team's saved naming, folder, and step conventions plus the project policy page. Call `memory_read` on headlines that match this job. Follow a convention when it applies and quote it. Never present it as a platform fact. If `available` is false, say memory is unavailable and do not conclude that the team has no conventions. Memory is optional: carry on when it is empty. Never call `memory_write` or `memory_forget` on your own. Use them only when the user asks you to remember or forget something.
## Pick the source
| The user has | Start here |
|---|---|
| A requirement key | `find_requirements` or `read_requirement`, then "Analyze the requirement" below. Read `customFields` too: acceptance criteria often live there. |
| Free text or a pasted spec | Analyze it locally. Link only when a real requirement ID is known. |
| Captured user sessions, a journey map, or one journey-map flow | `references/from-truetest-sessions.md` |
## Analyze the requirement
Track these points: intent, personas, main flow, alternate and negative flows, data and environment assumptions, risk areas, and the coverage you recommend. Read `references/requirement-analysis.md` before analyzing a non-trivial requirement.
## Design coverage
Rank first, then apply techniques.
1. **Rank by risk.** Score each requirement line by impact and likelihood of failure. Use defect history when it helps (`fetch_defect_metrics` with `filter_type` `DATE_RANGE` or `ITERATION`). Check `fetch_defects` for defects already linked to the cases you reuse. Put the most cases where the risk is highest.
2. **Apply techniques as tools.** ISTQB techniques (equivalence partitioning, boundary values, decision tables, state transitions, use-case scenarios, error guessing, pairwise) help you find cases. They do not prove coverage is complete. Model-based views such as a state diagram or a journey map are equal tools.
3. **State the gap.** Report what the design leaves uncovered and why. Never imply full coverage.
The deliverable is plain platform test cases. Read `references/istqb-coverage.md` before creating cases from requirements, and `references/manual-test-case-format.md` before importing several cases.
### Make each case atomic
Each case targets one validation condition (one acceptance line). It must still be a complete flow that runs on its own.
- Atomic limits the scope under test. It does not limit the step count. Every case walks the real path: precondition and navigation, valid surrounding data, the action under test, the expected result. A lone step such as "count the columns" is too thin. Run with AI cannot execute it.
- Split each input class, required field, boundary value, and error message into its own case. A password rule of "minimum 8 characters, one letter, one number, no spaces" becomes separate cases for 7 characters, exactly 8 characters, letters only, numbers only, and a space. Each case fills the whole form and submits. Only the field under test differs.
- Cover the main success flow and the boundary and negative variants around it.
- Combine features only in true end-to-end scenarios, such as register, log in, and land on the dashboard.
- Reason: a case that mixes conditions fails as a whole. The result cannot say which rule broke, and the requirement-line to test-result trace is lost.
- Quote expected error and UI strings verbatim from the requirement, including source typos. Flag a suspected typo separately. Never correct it silently in the expected result.
## Platform constraints
- Test case names accept only letters, numbers, spaces, and `( ) . , _ -`. Keep `@`, `:`, and `/` out of titles. Put them in descriptions or steps. Folder paths may use `/`.
- Test case names start with a letter or digit. `path` starts with `Test Cases` or `Test Cases/`.
- Prefer `update_test_cases` over delete and recreate. `delete_test_case` is unreliable. Updating keeps IDs, links, and history.
- `create_test_case` with `test_case_type` `AUTOMATED` creates nothing. It returns the next action for script generation. Create manual cases only.
- Suites reject a mix of MANUAL and AUTOMATED cases.
- No tool looks up assignees or the signed-in user. Leave the assignee empty unless the user supplies a valid UUID.
- A step that calls another case uses the step `action` object (`type` `call`, `test_case_id`, `version`). Never write it as a plain step named "Call test case 12".
- `update_test_cases` with `UPDATE_CONTENT` replaces all steps. Send the complete step list and keep Call Test Case steps. Omit `context` or include `expectedResult`. Never send `context: {}`.
## Check existing cases
This step is mandatory before every create, including retries after a partial failure.
1. If requirement IDs are known, call `find_test_cases_by_requirement`. Pass exactly one of the requirement identifiers it accepts.
2. Search with `find_test_cases` by requirement key, title keywords, feature area, and target folder.
3. Run `search` with `types: ["test_case"]` and `include_documents: false` for the same wording. It finds cases that keyword filters miss. Judge "exists" by the result tier (exact or strong), never by score alone. A response with `incomplete=true`, `retrieval_mode="keyword_fallback"`, or a warning never proves that a case is absent. Cases created in the last few minutes may not be searchable yet, so hedge any absence claim.
4. Read likely matches with `read_test_cases` (`content_type` `FLOW` for steps) when the title alone cannot settle coverage. A `search` hit gives a title and ref only.
5. Reuse, update, move, or link existing cases that already cover the behavior.
6. Create new cases only for uncovered behavior, missing coverage classes, or clearly obsolete cases.
Never create a duplicate because an earlier create call failed. Search again first.
## Write in three phases: plan, validate, execute
Follow `references/write-policy.md`. One write set gets one confirmation. For more than a handful of cases, use the bulk plan in `references/bulk-write-plan.md`.
1. **Plan.** List every proposed create, update, link, move, and suite change. Mark each as reuse, update, or new.
2. **Validate.** Check the plan before any write: name charset, duplicate titles inside the plan and against existing cases, folder exists or is in the plan, requirement IDs are real, suite members share one type. Fix the plan before you touch the platform.
3. **Execute.** Show the plan summary. Get one confirmation. Then write in this order.
1. `create_test_case` for uncovered manual cases only.
2. `update_test_cases` for revisions. Put every change to one case in one call: actions run in order, so separate calls for one case race. Each item is `{action, test_case_data: {id, ...}}` with one action per field (`RENAME`, `UPDATE_STATUS`, `UPDATE_DESCRIPTION`, `UPDATE_PRECONDITION`, `UPDATE_PRIORITY`, `UPDATE_AUTOMATION_STATUS`, `UPDATE_CUSTOM_FIELD`, `UPDATE_ASSIGNEE`, `UPDATE_LINKED_TEST_CASES`, `REMOVE_LINKED_TEST_CASE`, `UPDATE_CONTENT`). `repository_id` is required.
3. `manage_requirement_test_case_linkages` with `action` `link`, `requirement_ids`, `test_case_ids`, and `project_id`, only after the requirement IDs are known. The call is many-to-many and runs per requirement in parallel. A partial failure leaves some requirements updated, so read back with `find_test_cases_by_requirement`.
4. `manage_test_folder` or `move_test_case` when organization was requested or is clearly needed.
4. **Read back.** Call `read_test_cases` with `content_type` `FLOW` for created and updated cases. Compare the result with the plan. Report any mismatch.
Case shape: title, description, pre-condition, steps, expected results, test data, priority, requirement links.
## Suites
When the user asks for a suite or test plan from the cases:
1. Search with `find_test_suites` before creating anything. Check `find_test_suite_collections` when the user names a collection.
2. Read likely matches with `read_test_suite`.
3. Reuse a matching suite and add the missing cases.
4. Call `manage_test_suite` to create a suite only when none fits.
5. Verify the final suite with `read_test_suite`.
Suite collections are read-only here. No tool creates or edits them.
## Report
State what was reused, updated, created, linked, and left uncovered. Name the risk ranking you used and the gaps that remain.
## Hand-offs
- Unscripted discovery first: `exploratory-charter`.
- Values, fixtures, and cleanup for the cases: `test-data`.
- Inventory hygiene and traceability audits: `test-management`.
- Running the cases: `execute-test`.