create-test-cases · v0.6.0 · 2026-11-16 · sha256 4d6e7ac2fdb9a8ed
create-test-cases v0.6.0A
Immutable. This exact content never changes and is served at /api/v1/blob/4d6e7ac2fdb9a8ed.
No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_taiwiusuccuzdhwt/4d6e7ac2fdb9a8edc9a78b8726f34f27c2895d8f3b9564f1d0db6f69cffce6b4.json
Then /plugin install create-test-cases@markdownregistry-taiwiusuccuzdhwt 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, tags, 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.6.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 (including tags, feature areas, and custom test types), 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 `/`.
- A name with `%` or `$` is rejected. Katalon AI once retried after a second approval and saved the name without those characters. Leave both out.
- 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` takes every writable field since 2026-11-05: tags, feature areas, custom test types, and linked requirement IDs. A new tag name is created on the fly. It does not take `linkedTestCaseIds`, `linkedRequirementKeys`, or `testFolderId`. Set the folder with `path`. Link a requirement key with `manage_requirement_test_case_linkages`.
- A write can time out. `create_test_case` returned HTTP 504 under concurrent load. Do not assume the case was or was not created. Read back with `find_test_cases` before any retry.
- A short prompt such as "detail 2 test case" can read as a create request. If the intent is ambiguous, ask whether the user wants to read or to create before you call `create_test_case`.
- `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: {}`.
- `update_test_cases` also sets or clears tags, feature areas, and custom test types, and `origin` is read-only. The action names for these lists are not in the confirmed contract. Read the tool schema before the first call and use only the actions it lists. Each list clears on its own, so send an empty list only to clear it.
- Katalon AI and other agents can report an update that did not land. Never trust the call result alone. Read the case back.
## 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, tags, custom test type, and target folder. The `tags` and `customTestTypes` filters take name lists. An unknown name returns an error that lists the valid names and runs no search. The name filter takes an array, so send `name =in= ["logout","log out"]`. A comma-joined string matches nothing.
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. Add `include_attributes` to check tags, feature areas, custom test types, author, and assignee (the assignee comes back as a UUID only). Compare the result with the plan. Report any mismatch. After a timeout, read back with `find_test_cases` before you retry.
Case shape: title, description, pre-condition, steps, expected results, test data, priority, requirement links.
## Agent rules and Call Test Case steps
Katalon AI drafts add a Call Test Case step at step 1 when an agent rule names a shared flow such as a login case (since the 2026-11-05 release). An explicit call in the prompt wins over the rule. When you draft by hand and a rule names a shared flow, write the step as a call action and read the target case first with `read_test_cases`. Check for a duplicate call step before you write. Known gaps are in `references/agent-rule-calls.md`.
## 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, cleanup, and datasets for the cases: `test-data`.
- Inventory hygiene and traceability audits: `test-management`.
- Running the cases: `execute-test`.