open-testing-convert-cucumber

name	open-testing-convert-cucumber
description	Convert Cucumber BDD suites (feature files + step definitions) to and from Eggplant (SenseTalk), OpenTest.AI, Testers.AI Recorder, Testers.AI Dynamic, Selenium, Playwright, Cypress, and Appium. Handles Cucumber-JVM (Java/Kotlin/Scala), Cucumber-Ruby, Cucumber.js (JavaScript/TypeScript), SpecFlow (.NET), Behave (Python), and Behat (PHP). Converts Gherkin syntax (Feature/Scenario/Background/Scenario Outline/Examples) plus the underlying step-definition layer, preserving tags, hooks, data tables, and doc strings. Use whenever the user wants to migrate a Cucumber project, translate a single .feature file, or round-trip BDD through another framework. MANDATORY TRIGGERS — "convert Cucumber", "Cucumber to Playwright", "Gherkin to Selenium", "BDD to OpenTest.AI", "migrate feature files", "translate cucumber", "port SpecFlow", "Behave to Playwright", "Cucumber.js to Cypress", "Cucumber → Testers.AI", or any mention of `.feature` / Gherkin alongside any of the supported targets.
license	MIT
metadata	{"family":"open-testing-convert","source":"cucumber","orchestrator":"open-testing-convert","targets":["eggplant","opentestai","testersai-recorder","testersai-dynamic","selenium","playwright","cypress","appium"]}

Convert — Cucumber / Gherkin BDD

Converts BDD suites from Cucumber-style Gherkin (feature files + step definitions) to any supported target, and to Cucumber from another framework. Delegates orchestration, cross-framework rules, and target semantics to the open-testing-convert master skill.

When to use

Trigger when:

• The user references a .feature file or any of: Cucumber, Cucumber-JVM, Cucumber-Ruby, Cucumber.js, SpecFlow, Behave, Behat.
• The user asks to convert to a Cucumber/Gherkin suite from another framework.
• The user uploads files in these shapes:
  • *.feature (Gherkin source).
  • Step-definition files: Java/Kotlin with @Given/@When/@Then, Ruby with Given(/.../) do ... end, JS/TS with Given('...', function() {...}) (from @cucumber/cucumber), C# with [Given(...)]/[When(...)]/[Then(...)] (SpecFlow), Python @given/@when/@then decorators (Behave), PHP @Given/@When/@Then annotations (Behat).
  • cucumber.js, cucumber.json, cucumber.yml, features/support/env.rb, behave.ini, specflow.json.

How to use

1. Read the master orchestrator first. Open ../open-testing-convert/SKILL.md.
2. Confirm target. Cucumber has two layers (feature files + step definitions), so target decisions may differ per layer:
   • For natural-language targets (OpenTest.AI, Testers.AI Recorder, Testers.AI Dynamic, Eggplant Mode B): the scenarios themselves convert directly from the feature file; step definitions are effectively merged into the prose.
   • For code targets (Selenium, Playwright, Cypress, Appium, Eggplant Mode C): the feature file's scenarios become test methods, and the step-definition bodies are inlined as the method body.
   • For round-trip to Cucumber: synthesise both feature file and step-definition skeletons.
3. Determine the action layer language. The underlying step-definition language (Java, Ruby, JS, Python, C#, PHP) is the "implementation language" that the converter processes to build canonical intent. Delegate to the relevant per-source skill:
   • Selenium under Cucumber-JVM → open-testing-convert-selenium for the action layer.
   • Playwright under Cucumber.js → open-testing-convert-playwright for the action layer.
   • Cypress with @badeball/cypress-cucumber-preprocessor → open-testing-convert-cypress for the action layer.
   • Appium under Cucumber-JVM → open-testing-convert-appium for the action layer.
   • Pure Gherkin (feature file only, no step defs visible) → treat scenarios as natural-language canonical steps directly.
4. Read the relevant target primer:
   • ../open-testing-convert/reference/targets/eggplant.md
   • ../open-testing-convert/reference/targets/opentestai.md
   • ../open-testing-convert/reference/targets/testersai-recorder.md
   • ../open-testing-convert/reference/targets/testersai-dynamic.md
5. Read this skill's reference files:
   • reference/source-profile.md — Gherkin syntax and step-definition shapes across bindings.
   • reference/extraction.md — how to stitch feature file + step definitions into canonical intent.
   • reference/mappings.md — per-target translation tables and worked examples.
6. Read shared references — open-testing-convert/reference/shared/{locator-mapping,wait-strategies,assertion-mapping,lifecycle-mapping}.md — only when the step-definition layer uses a web or mobile driver.
7. Emit the converted test(s) according to the target primer's Emission Checklist. Produce a preamble summarising: source feature file(s), step-definition language, underlying driver (Selenium/Playwright/Cypress/Appium/none), target, language choice, resolved step definitions, any TODOs.

Scope

• Cucumber-JVM 6.x and 7.x (Java, Kotlin, Scala). Step annotations: @Given, @When, @Then, @And, @But (deprecated with Gherkin 6), @Before, @After.
• Cucumber-Ruby 3.x+.
• Cucumber.js / @cucumber/cucumber 8.x+ (JS/TS).
• SpecFlow (.NET Framework and .NET Core) — [Given]/[When]/[Then] / [BeforeScenario] / [AfterScenario].
• Behave (Python) — @given, @when, @then, @step, @before_scenario, @after_scenario, environment.py.
• Behat (PHP) — @Given, @When, @Then, @BeforeScenario, @AfterScenario.
• Gherkin 6 — Rule keyword, Scenario Outline / Scenario Template, Examples, Background, data tables, doc strings ("""), tags (@x).
• Parameter types ({int}, {word}, {string}, custom transforms) and regex-based step definitions.
• Hooks (Before/After, BeforeAll/AfterAll, tagged hooks @Before("@smoke")).

Out of scope (delegate to sibling skills)

• Raw .spec / .test files without Gherkin — use the direct framework skill (selenium, playwright, cypress, appium).
• Karate DSL (which uses Gherkin but has its own runtime) — use open-testing-convert-karate (Task #8 expansion).
• Gauge (Thoughtworks) — different syntax and structure; use open-testing-convert-gauge (Task #8 expansion).
• Robot Framework (tabular keyword-driven, not Gherkin) — use open-testing-convert-robot (Task #8 expansion).

Two-layer conversion principle

Cucumber is not a single-layer conversion. Every feature file implies a step-definition layer that performs the actions. When converting:

Target type	Feature-file layer	Step-def layer
Code target (Selenium/Playwright/Cypress/Appium)	mapped to test-method name + comments	inlined into test-method body; driver calls preserved
Natural-language target (OpenTest.AI/Dynamic)	scenarios become test_cases, steps become test_steps[]	step-def body informs the natural-language prose but is not emitted
Recorded target (Testers.AI Recorder)	scenarios become tests[], steps become test_steps[] + skeleton recordedActions[]	step-def body drives derivable selectorHints
Eggplant Mode C	scenarios become .script procedures	step-def body inlined
Eggplant Mode A/B	scenarios become procedures; action steps derived from natural phrasing	step-def body may be discarded (prose is enough)
Round-trip to Cucumber	feature file is regenerated	step-def skeleton is generated with TODOs where the source target lacks explicit step semantics

Quick reference: Gherkin primitives and canonical conversions

Gherkin	Canonical
Feature: X	suite/name
Background:	lifecycle.beforeEach
Scenario: Y / Example: Y	one canonical test
Scenario Outline: Z + Examples:	expand to N canonical tests (one per Examples row)
Given / When / Then / And / But	canonical steps (keyword preserved in metadata)
@tag	metadata.tags += [tag]
Data table (inline pipe-delimited)	step data payload
Doc string (triple-quoted)	step data payload (text block)
Rule: (Gherkin 6)	preserve as section metadata; inner scenarios are nested tests

See reference/mappings.md for the full per-target cookbook.