agentleFS
SimonKreis-RichardSimonKreis-Richard/oracle-fusion-agentic-toolkit/skills/fusion-test/SKILL.md

fusion-test

Skill0 starsChanged 51 days agoMITView on GitHub

Run a written test scenario in an Oracle Fusion TEST instance, end to end, from one approval of the whole plan. Use when a controlled experiment, a reproduction, a retest after a configuration change or a regression check has to be executed as a sequence of steps, when the user asks to run, replay or automate a test in the test pod, or to turn test steps into a blueprint. Writes the blueprint, shows it, records the approval, runs it, repairs a renamed label within the plan, resumes a stopped run where it stopped, cleans up what an abandoned run created, keeps sessions short, produces the report for the brief and the evidence document for the client, and runs the parts of a chain in order. Never production. Not for reading one value or making one change (fusion-instance), and not for deciding what to test (hcm-debugging step 5, hcm-configuration step 7).

The file

We split this skill into the rules it gives an agent

11 rules. About 0 are common, 5 are distinctive, and 6 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 6

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    When a label appears twice, add hints: { section: "<panel name>" } or hints: { index: 1 }.

    line 71
  2. Very specific:

    After a plan change, resume without --from is refused, because step numbers may have moved: read the plan again and give the number of the …

    line 158
  3. Distinctive:

    Stop and ask the user instead: when the fix would be anything else: a step added, removed or moved, a different action, a different value, …

    line 176
  4. Distinctive:

    Never send it yourself: it shows client screens.

    line 201
  5. Very specific:

    Every navigation path that ran, or was repaired, is evidence for skills/fusion-reference/navigation.md: add or fix the row there, generic …

    line 203
  6. Very specific:

    When it stops, nothing more is removed: tell the user exactly what is left, by run id.

    line 216
  7. Distinctive:

    Every turn of the agent rereads the whole conversation.

    line 222
  8. Distinctive:

    Hand over rather than drag on: When the conversation is long (it was compacted once, or many tool results have piled up), when the work …

    line 228
  9. Very specific:

    Compaction is the user's command, not yours: When a session must go on, suggest /compact with what to keep: the scenario, the run ids and …

    line 243
  10. Very specific:

    Never production. A run never leaves the pod of FUSION_BASE_URL.

    line 252
  11. Distinctive:

    Never a credential, never a sign in on the user's behalf, never a sign in step in a blueprint.

    line 253

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Running an approved test plan

A test is a plan written in advance, a blueprint, and it is run as written. The agent improvises only where a step is blocked because Oracle renamed something, and then only inside the plan. A run that improvises its path is no longer a test. (D23, D24 in memory/PROJECT.md.)

The window, the sign in and the production guard are those of fusion-instance: read its Setup section first. The person signs in; never type a credential.

1. Write the blueprint

From the controlled experiment of hcm-debugging step 5, or the verification plan of hcm-configuration. One blueprint is one signed in person: a test that needs a requester then an approver is two blueprints, run in order, and the user signs in as the other account in between.

Where it goes: fusion/blueprints/<scenario>.yaml in the engagement directory, never in this repository. Its data profile, when it has one: fusion/data/<name>.yaml beside it.

scenario: retest_document_type_security     # snake_case, also the report title
source: PROJ-1234                            # the ticket
ui: redwood
description: >
  One sentence: what this proves, and the expected outcome.
data_profile: retest                         # optional, file fusion/data/retest.yaml

steps:
  - action: navigate
    path: ["Navigator", "My Client Groups", "Document Records"]
  - action: fill
    label: "Name"                            # the label exactly as on screen
    value: "TEST {{run_id}}"                 # a subject created for the test (D20), named by the run
  - action: select
    label: "Document Type"
    value: "{{doc_type}}"                    # from the data profile
  - action: select
    label: "Status"
    value: "Active"
    mode: dropdown                           # a plain choice list, not a type ahead
  - action: click
    label: "Submit"
  - action: verify
    text_contains: "submitted"

cleanup:                                     # optional: removes what ONE run created, see step 6
  - action: navigate
    path: ["Navigator", "My Client Groups", "Document Records"]
  - action: fill
    label: "Search"
    value: "{{run_id}}"                      # finds this run's record, and nothing else
  - action: click
    label: "Delete"
  - action: click
    label: "Yes"

The eleven actions: navigate (path of labels from the home page, D19), click (double: true), fill (press_enter: true), select (mode: lov default or dropdown, match: exact or contains), press_key (key, optional label), capture (label, as: reuse later as {{name}}), verify (text_contains, or label with equals or contains), wait_for (text or label, state), switch_window (to: new or main), close_window, refresh.

Rules for writing one:

  • Labels, never selectors. No xpath, selector or CSS anywhere: the loader refuses them. When a label appears twice, add hints: { section: "<panel name>" } or hints: { index: 1 }.
  • Every path starts at the home page, because every run starts there.
  • End with a verify, or the run proves only that the last step was reached.
  • Name what the run creates with {{run_id}}, a value every run carries (20260924-215122-<scenario>). It makes the created record findable by the cleanup of that run, and by nothing else.
  • Generators for other values: {{random_string(n)}}, {{random_number(n)}}, {{today}}, {{today(+7)}}, {{today_us}}, {{timestamp}}. A generator gives a new value at each use; a value used twice (typed, then verified) comes from the profile or from {{run_id}}.
  • Give it a cleanup section whenever the flow saves anything before its end. A Redwood guided flow often autosaves a draft at the first Continue: every interrupted run then leaves a record in the pod. The cleanup is part of the plan and of its approval, so deleting stays approved.
  • Add-to-list pickers (a person that goes into a grid, the field emptying itself) need skip_confirm: true; the next Continue proves the pick by stopping when it is missing.
  • A profile value may itself be a generator (requisition_title: "TEST {{random_string(6)}}"). It is drawn once when the run starts, so the value typed at one step is the value searched or verified at another, and a resume keeps it.
  • The format is clockwork's, plus the optional cleanup key, which clockwork ignores (D25).

Blueprints converted by clockwork

They follow the same format and carry two markers of their own (D26):

  • PICK, a label such as PICK the employee in the search results: a row that only exists at run time. plan lists these steps, and the run always stops there (exit 3). When the criterion is objective, find the row that meets it on the page and repair with its label: the approval of the plan covers applying it (approved 2026-09-24). The blueprint keeps its criterion, and the journal the row picked for this run. Some PICK steps are a person's work by nature (a file dialog, a code sent by email, a time card grid, a drag): ask the user to act in the window, then resume <run-id> --from <the next step>; the evidence shows that step as done by the tester.
  • FILL, a profile value such as "FILL, the business unit": a value the source script never named. plan says NOT READY, a plan approval is refused and run refuses the plan until it is filled. Propose the value from a read of the pod (rest, snapshot), and let the user confirm it: it becomes part of the approved plan. Under an intent approval, the agent chooses it (fusion-suite).

A whole suite of such blueprints, worked through in a loop, with scripts rebuilt from their intent when they are wrong, is fusion-suite.

A chain is one scenario split per person: <name>_1, <name>_2, ... run in order, the user signing in as the next person in between. Each part after the first starts with the values of the previous part, drawn or captured, so part 2 finds what part 1 created:

npm run fusion -- run <scenario>_2 --after <run-id of part 1>

2. Show the plan and get one yes

npm run fusion -- plan <scenario>

Paste the numbered steps into the conversation, say what the run will change in the test pod and which steps commit (marked <- commits), and wait for an explicit yes. That yes covers every step of this plan, commits included, in the test pod only. Then, and only then:

npm run fusion -- approve <scenario>

Any later change to a step, an action, a value or the data profile invalidates the approval: run refuses it, and the plan goes back to the user. A label repair does not.

3. Run

npm run fusion -- run <scenario>

It starts from the home page, runs every step, screenshots each one, and checks for an Oracle error after each one. The exit code says what happened:

ExitMeaningYour move
0finished, every step passedstep 5
3blocked: a label was not found, or matched several elementsstep 4
4Oracle refused an operation, text quoted verbatima result: report it, never work around it
5signed outask the user to sign in, then resume <run-id>
6a step failed otherwise (a value that did not stick, a verify that failed)a result, or a wrong plan: tell the user, never patch it silently; once fixed, resume (below)

Never start again from the top when a run can continue. The window is still where the run stopped, and so are the values it captured:

npm run fusion -- resume <run-id>              # restarts at the step that stopped (exit 5 or 6)
npm run fusion -- resume <run-id> --from N     # after a plan change and a new approval, or an Oracle error dealt with

After a plan change, resume without --from is refused, because step numbers may have moved: read the plan again and give the number of the step to run next. Start a new run only when the window has moved on since the stop.

4. Repair a blocked step, inside the plan

The stop message lists what is actionable on the page and the labels that look similar. Read the page if that is not enough (npm run fusion -- snapshot --max 8000), find what the control is called now, then:

npm run fusion -- repair <run-id> "<label as on screen>" [--nth N] [--within "<section>"]

The tool performs the same action with the same value, with only the label corrected, rewrites the blueprint file in place (comments kept, the repair dated), and carries on. That is what keeps a repair inside the approved plan by construction.

Stop and ask the user instead when the fix would be anything else: a step added, removed or moved, a different action, a different value, or a click that commits where the plan did not (the tool refuses that one by itself). Never reach for click --write to get past a blocked run.

5. Report

npm run fusion -- report <run-id>

Markdown with the steps, how each element was found, the repairs, and any Oracle error verbatim, saved beside the run in the engagement directory. Paste it into the evidence section of the brief, naming the instance (DEV1) on every fact as hcm-debugging requires. Screenshots stay in the run folder; never read them back into the conversation unless the user asks.

The document for the client is another file, in the format clockwork fixed: every step as a manual tester writes it, beside its screenshot, the expected result from the blueprint description, PASSED or FAILED per test, steps never reached shown as not run. One self contained HTML file and its PDF, in fusion/evidence/ of the engagement directory. Several runs make one document, the parts of a ticket side by side:

npm run fusion -- evidence <run-id> [<run-id>...]          # --layout stack: screenshot under the step

Never send it yourself: it shows client screens. Give the user the path.

Every navigation path that ran, or was repaired, is evidence for skills/fusion-reference/navigation.md: add or fix the row there, generic names only.

6. Clean up what a run leaves behind

A run that will not be resumed, or a finished one whose output is not to be kept, is cleaned up:

npm run fusion -- cleanup <run-id>

It runs the blueprint's cleanup section from the home page, with that run's {{run_id}}, so it removes what that run created and nothing else. It runs once per run and is recorded in the report. When it stops, nothing more is removed: tell the user exactly what is left, by run id. Without a cleanup section there is nothing to run, and deleting by hand outside a plan is a single change that needs its own yes (fusion-instance).

7. Keep the session small: runs are cheap, conversation is not

Every turn of the agent rereads the whole conversation. A run costs almost nothing, since only its last lines come back; what costs is a long conversation around it. On the first real pod, the calibration of one scenario took about a hundred turns in a conversation that was already long.

  • One session, one job. Writing and calibrating a new plan is one session. Running a batch of approved plans is another. Do not start test work at the end of a long ticket conversation.
  • Hand over rather than drag on. When the conversation is long (it was compacted once, or many tool results have piled up), when the work moves from calibrating to routine runs, or when several independent plans are left, stop and give the user a prompt to paste into a new session, filled in, for example:

    Use fusion-test. The Fusion window is open and I am signed in (check with `npm run fusion -- status`).
    Run these approved plans, one after the other: <scenario>, <scenario>.
    Repair a blocked label within the plan. On exit 6, or anything that changes the plan, stop and ask me.
    Resume a stopped run with `resume <run-id>`, never from the top. Clean up every run that will not be
    resumed with `cleanup <run-id>`. At the end, give me one line per run: outcome, report path, what is
    left in DEV1.
    Pending from the previous session: <run ids and their state, from `npm run fusion -- runs`>.
  • Compaction is the user's command, not yours. When a session must go on, suggest /compact with what to keep: the scenario, the run ids and their state, the approvals given.
  • Parallel sessions only on separate windows. Two sessions driving one window collide. Each parallel session needs its own FUSION_CDP_PORT and FUSION_PROFILE_DIR, and the user signs in in each window. Run in parallel only plans that touch different data; the default is one after the other in one window.

Hard rules

  • Never production. A run never leaves the pod of FUSION_BASE_URL.
  • Never a credential, never a sign in on the user's behalf, never a sign in step in a blueprint.
  • approve only after an explicit yes in the conversation, for that plan.
  • An Oracle error is never repaired, retried or worked around.
  • A repair changes a label or its hints, nothing else.
  • Nothing is deleted outside an approved cleanup section.
  • Blueprints, data profiles, runs and reports stay in the engagement directory.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.