fix(#1408): Add documentation for Citrus Cucumber steps

Author: christophd

src/manual/index.adoc

@@ -57,7 +57,6 @@ include::endpoint-ssh.adoc[]
 include::endpoint-rmi.adoc[]
 include::endpoint-jmx.adoc[]
 include::endpoint-zookeeper.adoc[]
-include::endpoint-restdocs.adoc[]
 include::endpoint-component.adoc[]
 include::endpoint-adapter.adoc[]
 
@@ -76,12 +75,13 @@ include::data-dictionary.adoc[]
 include::test-actors.adoc[]
 include::test-suite.adoc[]
 include::meta-info.adoc[]
-include::message-tracing.adoc[]
 include::reporting.adoc[]
 
 include::configuration.adoc[]
 include::spring-support.adoc[]
 
+include::tools.adoc[]
+
 include::samples.adoc[]
 
 include::appendix.adoc[]

src/manual/runtimes-cucumber.adoc

@@ -381,89 +381,119 @@ As usual, we are able to use *@CitrusResource* annotated *TestCaseRunner* fields
 logic. With this extension you can use the full Spring testing power in your tests in particular dependency injection and
 also transaction management for data persistence tests.
 
-[[yaks-step-definitions]]
-=== YAKS step definitions
+[[citrus-step-definitions]]
+=== Predefined step definitions
 
-https://github.com/citrusframework/yaks[YAKS] is a side project of Citrus and provides some predefined steps for typical
-integration test scenarios that you can use out-of-the-box.
+Citrus provides a set of predefined step implementations for typical integration test scenarios that you can use out-of-the-box in a Cucumber feature.
 
-You can basically define send/receive operations and many other predefined steps to handle Citrus test
-actions. As these steps are predefined in YAKS you just need to use them in your feature stories. The step definitions with
-glue to test actions is handled automatically in YAKS.
+You can basically define send/receive operations and many other predefined steps to leverage Citrus functionality such as endpoints and test
+actions. As these steps are predefined in Citrus you just need to add the step as a line in your feature stories. The step definitions with
+the glue to test actions is handled automatically when running Citrus with Cucumber.
 
-If you want to enable predefined steps support in your test you need to include the YAKS module as a Maven dependency.
+If you want to enable predefined steps support in your test you need to include the Citrus Cucumber steps module as a Maven dependency.
 
-.YAKS module dependency
+.Citrus Cucumber step module dependency
 [source,xml]
 ----
 <dependency>
-  <groupId>org.citrusframework.yaks</groupId>
-  <artifactId>yaks-standard</artifactId>
-  <version>${yaks.version}</version>
+  <groupId>org.citrusframework</groupId>
+  <artifactId>citrus-cucumber-core</artifactId>
+  <version>${citrus.version}</version>
   <scope>test</scope>
 </dependency>
 ----
 
 After that you need to include the glue code package in your test class like this:
 
-.Include YAKS steps
+.Include Citrus steps
 [source,java]
 ----
 @RunWith(Cucumber.class)
 @CucumberOptions(
-    extraGlue = { "org.citrusframework.yaks.standard" },
+    extraGlue = { "org.citrusframework.cucumber.steps" },
     plugin = { "pretty", "org.citrusframework.cucumber.CitrusReporter" } )
 public class MyFeatureIT {
 
 }
 ----
 
-Instead of writing the glue code on our own in step definition classes we include the glue package `org.citrusframework.yaks.standard`
-as extra glue. This automatically loads all YAKS step definitions in this module. Once you have done this you can use predefined
+Instead of writing the glue code on our own in step definition classes we include the glue package `org.citrusframework.cucumber.steps`
+as extra glue. This automatically loads all predefined Citrus step definitions. Once you have done this you can use predefined
 steps without having to write any glue code in Java.
 
-The YAKS framework provides the following modules with predefined steps:
+[source,gherkin]
+----
+Feature: Hello World
+
+  Scenario: Print Hello World
+    Given variable text="Hello World!"
+    Then print 'You just said: ${text}'
+
+----
+
+The feature uses the default predefined steps `Given variable <name>="<value>"` and `Then print '<output>'` provided by Citrus.
+
+The Citrus framework provides many different modules serving many different aspects of integration testing.
+You can add those steps with modular dependencies in Maven.
+See the following modules with predefined steps provided by Citrus:
 
-.YAKS modules
+.Citrus Cucumber step modules
 |===
 |Module |Description
 
-| yaks-standard
+| citrus-cucumber-core
 | Standard steps such as test variables, sleep/delay, log/print, ...
 
-| yaks-http
+| citrus-cucumber-http
 | Http steps for client and server side communication
 
-| yaks-openapi
+| citrus-cucumber-openapi
 | Load Open API specifications and invoke/verify operations with generated test data
 
-| yaks-kubernetes
+| citrus-cucumber-kubernetes
 | Manage Kubernetes resources (e.g. pods, deployments, custom resources)
 
-| yaks-knative
+| citrus-cucumber-knative
 | Steps to connect with Knative eventing and messaging
 
-| yaks-jms
+| citrus-cucumber-jms
 | Send/receive steps via JMS queues/topics
 
-| yaks-kafka
+| citrus-cucumber-kafka
 | Steps to publish/subscribe on Kafka messaging
 
-| yaks-jdbc
+| citrus-cucumber-jdbc
 | Steps to connect to relational databases
 
-| yaks-camel
+| citrus-cucumber-camel
 | Steps to access Apache Camel components and Camel routes
 
-| yaks-camel-k
-| Manage Camel-K resources on Kubernetes
-
-| yaks-selenium
+| citrus-cucumber-selenium
 | Run UI tests with Selenium using Selenium grid or standalone containers
 
-| yaks-groovy
+| citrus-cucumber-groovy
 | Leverage Groovy scripts as Citrus endpoint and component configuration
+
+| citrus-cucumber-testcontainers
+| Manage Testcontainers instances with starting/stopping databases, message brokers and many more
+
 |===
 
-Once again it should be said that the step definitions included in this modules can be used out-of-the-box. You can start
-to write feature stories in Gherkin syntax that trigger the predefined steps.
+Once again it is important to understand that the predefined step definitions included in these modules can be used out-of-the-box.
+You can just start to write BDD features in Gherkin syntax that trigger these predefined steps.
+
+
+TIP: If you want to include all available step definitions into your project at once you can use the `citrus-cucumber-all` module dependency.
+
+.Include all Citrus Cucumber steps
+[source,xml]
+----
+<dependency>
+  <groupId>org.citrusframework</groupId>
+  <artifactId>citrus-cucumber-all</artifactId>
+  <version>${citrus.version}</version>
+  <scope>test</scope>
+</dependency>
+----
+
+Read more about the individual step implementations and their functionality in xref:tools-cucumber-steps[Tools - Citrus Cucumber steps].

src/manual/runtimes-jbang.adoc

@@ -261,13 +261,13 @@ Feature: EchoTest
 .Run my-test.feature
 [source,shell]
 ----
-jbang --deps org.citrusframework.yaks:yaks-standard:0.20.0 citrus run my-test.feature
+jbang --deps org.citrusframework:citrus-cucumber-all:4.9.0-SNAPSHOT citrus run my-test.feature
 ----
 
-NOTE: Many of the predefined Cucumber steps (e.g. `Then print '<message>'`) in Citrus are provided in a separate Citrus child project called https://github.com/citrusframework/yaks[YAKS].
+NOTE: Many of the predefined Cucumber steps (e.g. `Then print '<message>'`) in Citrus are provided in separate Citrus modules.
 You need to add additional project dependencies for that steps to be loaded as part of the JBang script.
 The `--deps` option adds dependencies using Maven artifact coordinates.
-You may add the additional modules to the `jbang.properties` as described in the next section.
+You may also add the additional modules to the `jbang.properties` as described in the next section.
 
 [[runtime-jbang-dependencies]]
 === Additional JBang dependencies
@@ -304,8 +304,7 @@ The file above adds the modules `citrus-camel`, `citrus-testcontainers` and `cit
 
 The `jbang.properties` file may be located right next to the test source file or in your user home directory for global settings.
 
-IMPORTANT: In case you want to run Cucumber BDD Gherkin feature files and use the predefined steps included in the https://github.com/citrusframework/yaks[YAKS] project,
-you need to add this YAKS runtime dependency accordingly: `org.citrusframework.yaks:yaks-standard:0.20.0`
+IMPORTANT: In case you want to run Cucumber BDD Gherkin feature files and use the predefined Citrus steps, you need to add this dependency accordingly: `org.citrusframework:citrus-cucumber-all:4.9.0-SNAPSHOT`
 
 [[runtime-jbang-clipboard]]
 === Run from clipboard