macros4cuke 0.4.07 → 0.4.08

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDJhOGYwNDM3NTRiYjMwZGFlZDA4MmUxMGRlMzM2YjUzODM2NDM3ZA==
+    MjExN2JjMDk1OTE2MDAyODlmNzFlYjU5MjBhNzBjM2U3MTYwNjA1MA==
   data.tar.gz: !binary |-
-    ODU0NDllNDUxM2I5NDI4OTdhYWY2MDJmOTBiNjY5ODZhNDNlYWMyNg==
+    M2NhYzE4ZjkxOGExNGZkODNjYTI0YWEyYTA0MzJiY2I4MzkwNzdjOA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    M2NkODM4ZDRmNzA0YWViZjAwZTExM2M3M2I0YThmYTcxY2E1YThlYzYzMmUz
-    YzE0OGFiNzE2NWRiMmUwMWFhNzQ5MmY5Y2E4YTNkY2M4MzU3ODNhMDNkNjUy
-    ZWI4ZjdiOTU2OTVmZGVjOTIxYzU2ZmQ5ZmE3NTg4MWM0N2IzMTk=
+    MDliNGIyNDBmZjhlOGNjMjg2ZjRhNGRiZWY0NjM2ZTc2N2IzMzUxNTg1Mzgz
+    NGE3OTVkMTM3YzMyMTc1MTQwODk3YjhjMzdhOWQzMmNjNDE5MjE1MjIzOGEx
+    NmY0NjIwM2ExMzBkOTBmNDg1YWMyYTU3YmM1ZWNjOGYwNDYxMjQ=
   data.tar.gz: !binary |-
-    YjZmMmZhOGI0MjdhMjFkM2QyYmYwMmZiNDE3OWRjOGE0YzQ1ODAyNmNiZTkz
-    ZTRhODk4MjJiNzE4MDkyZmU0ZmY2ZTZhZmZmYjc2M2RkZjYxYjcxMGU2MWRi
-    NDc1NzU0M2Q0NGIxOGJmZTBhMjVjMmFkYzIzNjBmY2Y1YzlhMjU=
+    M2QwZjk4ZTA2YTEyYWQxYjNhN2RlNDBkY2M5ZmI0MTM3ODA1YTFkMDQ1MDZl
+    M2UxNTllM2E1MWUyNTBlYjhhMjg0MzFiNDQ1NTExYmQ2N2NhZjdmZTc1MGFj
+    YmNhNzQyMzYyMDMwZTE2Y2Y5ZWQwNmE0ZjJiMThmMzUyMjk4MGI=

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 0.4.08 / 2014-02-08
+* [NEW] Added some tutorial material in [Relish] (https://www.relishapp.com/famished-tiger/macros4cuke/docs)
+* [CHANGE] `features` dir and feature files re-designed for publishing on Relish website.
+* [CHANGE] File `macros4cuke.gemspec`: RDOC is configured to use UTF-8 charset
+* [CHANGE] File `README.md`: Updated with links to Relish website.
+
 ### 0.4.07 / 2014-02-04
 * [FIX] Addressed Rubocop 0.18 complains string concatenation over multiple lines.
 * [CHANGE] File `formatting-service_spec.rb`: Replaced string operators + by newline escapes

data/README.md

@@ -7,11 +7,12 @@ Macros4Cuke
 
 _Add macros to your Cucumber scenarios._  
 [Homepage](https://github.com/famished-tiger/Macros4Cuke)
+[Documentation] (https://www.relishapp.com/famished-tiger/macros4cuke/docs)
 
-__Macros4Cuke__ is a lightweight library that adds a macro facility your Cucumber scenarios.  
-  With it, you can create any new step that replaces a sequence of substeps.
+__Macros4Cuke__ is a Cucumber extension that adds a macro facility for your Cucumber scenarios.  
+  With it, you can create any new step that replaces a sequence of sub-steps.
   All this can be done directly in your feature files without programming step definitions.
-  
+
 ### Highlights ###
 * Works with out-of-the-box Cucumber
 * Simple installation and setup (no programming required),
@@ -22,6 +23,7 @@ __Macros4Cuke__ is a lightweight library that adds a macro facility your Cucumbe
 * Domain neutral: applicable to any kind of application that can be driven with Cucumber,
 * A group of sub-steps can be made conditional.
 
+
 Since version 0.4.00, it is also possible to [list all the encountered macro definitions](#listing-all-the-macro-definitions). 
 
 ## A quick example ##
@@ -437,6 +439,15 @@ text in an entry field may be noticeably different than skipping that same entry
 Think of specific UI-events that can trigger some special system response.
 
 
+## More documentation ##
+More samples and documentation can be found in the `features` folder. It contains
+many feature files and README.md -in Markdown format-.
+Most of the material has been rewritten and adapted so that it can be consulted at the Relish website.
+Relish -The living document- website is great to turn your feature files into an attractive documentation.
+
+[Macros4Cuke @ Relish] (https://www.relishapp.com/famished-tiger/macros4cuke/docs)
+
+
 ## Listing all the macro definitions ##
 When one begins to write macros spread over a large collection of feature files
  it becomes interesting to have an overview, a list of all macro ever defined.  
@@ -526,4 +537,4 @@ Macros with Cucumber is a hot topic, so it is good to know what other people say
 
 Copyright
 ---------
-Copyright (c) 2013, Dimitri Geshef. Macros4Cuke is released under the MIT License see [LICENSE.txt](https://github.com/famished-tiger/Macros4Cuke/blob/master/LICENSE.txt) for details.
+Copyright (c) 2014, Dimitri Geshef. Macros4Cuke is released under the MIT License see [LICENSE.txt](https://github.com/famished-tiger/Macros4Cuke/blob/master/LICENSE.txt) for details.

data/features/1_Basics/README.md

@@ -0,0 +1,78 @@
+# A first example #
+Let's assume that our friend Joe wants to test a basic calculator.  
+Joe uses Cucumber with a generic library of user interface steps that
+allows him to perform user actions like:
+- Filling a text field,
+- Pressing on a button,
+- Clicking on a link,...
+
+
+For instance, the Cucumber steps necessary to calculate the sum of 8 + 3 are:
+```cucumber
+    When I type 8  
+    And I click Enter
+    And I type 3  
+    And I click Enter
+    And I click Add
+    Then I should see 11
+```
+
+
+What strikes Joe is that some step sequences are repeating again and again in
+many of his scenarios. As an example Joe would like to replace the scenario fragment:
+```cucumber
+    When I type 8  
+    And I click Enter
+```
+
+by something shorter like:
+```cucumber
+    When I enter the number 8
+```
+
+For a programmer familiar with Cucumber, Joe's wish is a piece of a cake to achieve.
+Alas, while Joe is a terrific tester he has little programming experience. Accordingly,
+he doesn't feel confident enough to program step definitions. Or maybe he isn't knowledgeable
+in the API used by the calculator...
+
+Luckily, Joe is rescued from despair and when he reads in the next paragraph how
+to get rid of the infamous scenario fragment.
+  
+
+With __Macros4Cuke__, all Joe has to do to create his wished new macro-step is:
+
+```cucumber
+    ...
+    Given I define the step "When I [enter the number <value>]" to mean:  
+    """  
+    When I type <value>  
+    And I click Enter 
+    """
+    ...
+```
+
+Once this is done, then the original scenario above can be rewritten as follows:
+```cucumber
+    When I [enter the number "8"]
+    And I [enter the number "3"]
+    And I click Add
+    Then I should see 11
+```
+
+No programming was required! The only price to pay are the step syntax conventions imposed by __Macros4Cuke__ (e.g. the square brackets and the quotes).
+But this is really bargain compared to the added convenience.
+
+With a little imagination, Joe could even reduce the last scenario to something like:
+```cucumber
+    When I [calculate the sum of "8" and "3"]
+    Then I should see 11
+```
+
+See how the last example looks more natural and readable for a genuine calculator user.
+
+Are you interested to reduce the length of your scenarios or do you want to use higher-level
+steps that conceal the boring details without fiddling with step definition programming?...
+
+Then give __Macros4Cuke__ a try...
+
+  

data/features/{demo01.feature → 1_Basics/demo01.feature}

@@ -1,16 +1,18 @@
 # File: demo01.feature
 
-Feature: Show the use of a basic macro
+Feature: Define and use a basic macro-step
   As a Cuke user
-  So that I enjoy writing scenario.
+  I want to create macro-steps that replace repeating lower-level steps
+  So that I can write shorter and more readable scenarios.
 
 
-Scenario: Definition of a simple macro-step
+Scenario: Defining a simple macro-step
   # The next step creates a macro(-step)
   # The syntax of the new macro-step is specified between double quotes.
   # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
   Given I define the step "* I [log in]" to mean:
   """
+  # Here follows the steps to execute when this macro is called
   Given I landed in the homepage
   When I click "Sign in"
   And I fill in "Username" with "johndoe"

data/features/2_Macros_with_arguments/README.md

@@ -0,0 +1,47 @@
+# Passing data values to a macro-step #
+
+Macro-steps as defined in the _Basics_ section are pretty limited. 
+
+Remember Joe and his calculator?...  
+Suppose that Joe created a macro-step as follows:
+```cucumber
+    ...
+    Given I define the step "When I [enter the number 8]" to mean:  
+    """  
+    When I type 8  
+    And I click Enter 
+    """
+    ...
+```
+
+While being a perfectly valid macro, it is almost useless since it will always enter the same digit 8.
+
+What Joe really needs is a macro-step that allows him to enter any number.  
+His wish, in turn, implies that the previous macro-step should accept one parameter value: the number to enter.
+
+Here is how Joe might proceed:
+```cucumber
+    ...
+    Given I define the step "When I [enter the number <some_number>]" to mean:  
+    """
+    When I type <some_number>  
+    And I click Enter 
+    """
+    ...
+```
+
+And here is how he can use the last macro to enter the value 2:
+
+```cucumber
+    ...
+    When I [enter the number "2"] 
+    ...
+```
+
+## Rules of the game ##
+When a macro-step is required to take one or more values, then:
+
+1. Place in the step being defined the name of an argument between chevrons < ... >.
+2. When the macro is used in a scenario, place the value of the corresponding argument between double quotes "...".
+
+

data/features/2_Macros_with_arguments/demo02.feature

@@ -0,0 +1,51 @@
+# File: demo02.feature
+
+Feature: Define and use a macro taking one argument
+  As a Cuke user
+  I want to pass data to macro-steps
+  So that I can use them in more varied situations.
+  
+
+
+Scenario: Defining a macro-step with one argument (userid)
+  # The next step creates a macro(-step)
+  # The syntax of the new macro-step to create is specified between the double quotes.
+  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
+  # The macro argument is put between chevrons <...>.
+  Given I define the step "* I [log in as <userid>]" to mean:
+  """
+  Given I landed in the homepage
+  When I click "Sign in"
+  # The next step uses the macro-step argument <userid>
+  And I fill in "Username" with "<userid>"
+  And I fill in "Password" with "unguessable"
+  And I click "Submit"
+  """
+
+Scenario: Use the macro created above pass it a user id
+  # Here the macro is invoked. Actual value for the argument is put between double quotes.
+  When I [log in as "guest"]
+
+  # The next step verifies that the steps from the macro were effectively executed.
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "guest"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """
+  
+  
+Scenario: Use the macro with another user id
+  When I [log in as "me-again"]
+
+  # The next step verifies that the steps from the macro were effectively executed.
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "me-again"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """

data/features/2_Macros_with_arguments/demo03.feature

@@ -0,0 +1,35 @@
+# File: demo03.feature
+
+Feature: Define and use a macro taking several arguments
+  As a Cuke user
+  I want versatile macro-steps that accept more than one data argument
+  So that I can use them in varied situations.
+
+
+Scenario: Defining a macro with multiple arguments
+  # The next step creates a macro(-step)double quotes.
+  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
+  # The macro-step arguments are put between chevrons <...>.
+  Given I define the step "* I [enter my userid <userid> and password <password>]" to mean:
+  """
+  Given I landed in the homepage
+  When I click "Sign in"
+  And I fill in "Username" with "<userid>"
+  And I fill in "Password" with "<password>"
+  And I click "Submit"
+  """
+
+Scenario: Using the macro with multiple arguments
+  # Here the macro is invoked. Actual value for the argument is put between double quotes.
+  When I [enter my userid "jdoe" and password "cosmic"]
+
+  # The next step verifies that the steps from the macro were effectively executed.
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "jdoe"
+Invoked step: ... I fill in "Password" with "cosmic"
+Invoked step: ... I click "Submit"
+  """
+

data/features/3_Macros_with_table_arguments/README.md

@@ -0,0 +1,88 @@
+# Passing values to a macro-step through a table #
+
+## Learned so far ##
+
+We discovered in the previous sections how to:
+- Create a macro-step, and
+- Pass data values to it.
+
+As a further, example, here is the of a macro-step that takes three arguments such as:
+```cucumber
+    Given I define the step "When I [fly from <origin> to <destination> via <stopover>]" to mean:
+    """
+    When I take-off from <origin>  
+    And I land in <stopover>
+    And I take-off from <stopover>
+    And I land in <destination>
+    """
+```
+
+Our macro-step can be used in a scenario like this:
+
+```cucumber
+    ...
+    When I [fly from "Copenhagen" to "Milan" via "Paris"]
+    ...
+```
+
+The text between double quotes, such as "Milan" are data values that the macro
+will use when it executes its own sub-steps.
+
+## Using a table to pass data to a macro-step ##
+
+While the use of macro-steps parameters is rather straightforward, it is however not always
+very practical in situations when:
+- A lot of arguments (say, more than 4) must be passed; or,
+- Some arguments take long text values.
+
+In these cases, with the approach described above we end up with steps that are 
+very long and hard to follow.
+
+Therefore, __Macros4Cuke__ provides an alternative step syntax that allows you to pass
+data values through a table.
+
+The syntax for the macro definition is almost the same as above
+
+```cucumber
+    Given I define the step "When I [fly to <destination>]:" to mean:
+    """
+    When I take-off from <from>  
+    And I land in <via>
+    And I take-off from <via>
+    And I land in <destination>
+    """
+```
+
+Did you spot the key difference? There is a colon ':' character right after the closing bracket ']'.
+It is this colon character that tells __Macros4Cuke__ that some arguments will be passed via a table.
+Also some argument names were changed in order to make the syntax of a call to the macro-step more natural.
+
+The syntax to call the macro with a table of arguments is as follows:
+```cucumber
+    When I [fly to "Milan"]:
+    |from |Copenhague|
+    |via  |Paris     |
+```
+
+There are three argument values. The first one "Milan" is passed directly in the step sentence.
+The two others are passed via a table.
+
+## Rules of the game ##
+Here are the conventions to apply when a macro-step is required to take values via a table.
+In the macro definition:
+1. Add a colon ':' just after the closing square bracket.
+2. You are allowed to pass also arguments in the step sentence.
+
+When calling the macro:
+3. The table used to pass arguments must have exactly two columns.
+4. The first column contains the argument names.
+5. The second column contains the argument values.
+6. A row consists of a pair argument name - its value
+
+ 
+
+
+
+
+
+

data/features/{demo04.feature → 3_Macros_with_table_arguments/demo04.feature}

@@ -1,8 +1,9 @@
 # File: demo04.feature
 
-Feature: Show the use of a macro with multiple arguments in a table
+Feature: Define and use a macro with arguments in a table
   As a Cuke user
-  So that I enjoy writing scenario.
+  I want to pass many arguments to a macro-step
+  So that I can use flexible and readable macros.
 
 
 Scenario: Defining a macro to be used with multiple arguments in a table
@@ -19,10 +20,10 @@ Scenario: Defining a macro to be used with multiple arguments in a table
   And I click "Submit"
   """
 
-Scenario: Let's use the macro we created above
+Scenario: Using the macro we created above
   # Here the macro is invoked. Actual value for the argument are passed in a table argument.
   When I [enter my credentials as]:
-  |userid|guest|
+  |userid  |guest      |
   |password|unguessable|
 
   # The next step verifies that the steps from the macro were effectively executed.

data/features/{demo05.feature → 3_Macros_with_table_arguments/demo05.feature}

@@ -1,8 +1,9 @@
 # File: demo05.feature
 
-Feature: Show the use of a macro with multiple arguments in a table
+Feature: Yet another example of: passing a Cucumber table into a macro-step
   As a Cuke user
-  So that I enjoy writing scenario.
+  I want to pass many arguments to a macro-step
+  So that I can use flexible and readable macros.
 
 
 Scenario: Defining a macro to be used with multiple arguments in a table
@@ -18,14 +19,14 @@ Scenario: Defining a macro to be used with multiple arguments in a table
   And I click "Save"
   """
 
-Scenario: Let's use the macro we created above
+Scenario: Using the macro we created above
   # Here the macro is invoked. Actual value for the argument are passed in a table argument.
   When I [enter my profile as]:
   |location|Nowhere-City|
-  |email|nobody@example.com|
-  |comment|First comment line|
-  |comment|Second comment line|
-  |comment|Third comment line|
+  |email   |nobody@example.com |
+  |comment |First comment line |
+  |comment |Second comment line|
+  |comment |Third comment line |
 
   # The next step verifies that the steps from the macro were effectively executed.
   Then I expect the following step trace:

data/features/5_Goodies/demo07.feature

@@ -0,0 +1,29 @@
+# File: demo07.feature
+
+Feature: Insert a call to existing macro-step inside a new macro
+  As a Cuke user
+  I want to be able to use a macro-step inside higher-level macro-steps
+  So that I can use a macro-step to execute complex step sequences
+  
+  
+Scenario: Create a macro that uses another, existing, macro (YES, it's possible!)
+  Given I define the step "* I [enter my credentials]" to mean:
+  """
+  # The next step invokes a macro-step defined elsewhere
+  When I [enter my userid "guest" and password "unguessable"]
+  """
+  
+Scenario: Invoking the coarse-grained macro
+
+  # Invoking our lastly-created macro
+  When I [enter my credentials]
+
+  # Check that the nested macro still works
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "guest"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """

data/features/{demo07.feature → 5_Goodies/demo08.feature}

@@ -1,4 +1,4 @@
-# File: demo07.feature
+# File: demo08.feature
 
 Feature: Save all encountered macro-step definitions in a single file
   As a prolific macro-step writer

data/features/README.md

@@ -0,0 +1,20 @@
+__Macros4Cuke__ is a Cucumber extension that allows you create and use new Cucumber steps without programming.
+    
+  With it, your scenarios will:  
+- become shorter since a macro-step can replace a bunch of sub-steps,
+- be more expressive by hiding low-level and boring details inside higher-level macro-steps,
+- be more flexible thanks to conditional steps you can put in a macro-step.
+ 
+  
+## The project
+  
+[Get the gem](https://rubygems.org/gems/macros4cuke)
+[Source on GitHub](https://github.com/famished-tiger/Macros4Cuke)
+
+## Issues
+
+This documentation is work in progress. If you find it incomplete or confusing, 
+please [submit an issue](https://github.com/famished-tiger/Macros4Cuke/issues).
+
+
+

data/lib/macros4cuke/constants.rb

@@ -3,7 +3,7 @@
 
 module Macros4Cuke # Module used as a namespace
   # The version number of the gem.
-  Version = '0.4.07'
+  Version = '0.4.08'
 
   # Brief description of the gem.
   Description = 'Macro-steps for Cucumber'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: macros4cuke
 version: !ruby/object:Gem::Version
-  version: 0.4.07
+  version: 0.4.08
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-04 00:00:00.000000000 Z
+date: 2014-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -131,13 +131,18 @@ files:
 - examples/i18n/fr/features/step_definitions/demo_steps.rb
 - examples/i18n/fr/features/step_definitions/use_macro_steps.rb
 - examples/i18n/fr/features/support/macro_support.rb
-- features/demo01.feature
-- features/demo02.feature
-- features/demo03.feature
-- features/demo04.feature
-- features/demo05.feature
-- features/demo06.feature
-- features/demo07.feature
+- features/1_Basics/demo01.feature
+- features/2_Macros_with_arguments/demo02.feature
+- features/2_Macros_with_arguments/demo03.feature
+- features/3_Macros_with_table_arguments/demo04.feature
+- features/3_Macros_with_table_arguments/demo05.feature
+- features/4_Conditional_steps/demo06.feature
+- features/5_Goodies/demo07.feature
+- features/5_Goodies/demo08.feature
+- features/1_Basics/README.md
+- features/2_Macros_with_arguments/README.md
+- features/3_Macros_with_table_arguments/README.md
+- features/README.md
 - features/step_definitions/demo_steps.rb
 - features/step_definitions/use_macro_steps.rb
 - features/support/env.rb
@@ -169,7 +174,7 @@ post_install_message: ! '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 '
 rdoc_options:
-- --exclude="examples|features|spec"
+- --charset=UTF-8 --exclude="examples|features|spec"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement

data/features/demo02.feature

@@ -1,34 +0,0 @@
-# File: demo02.feature
-
-Feature: Show the use of a basic macro with one argument
-  As a Cuke user
-  So that I enjoy writing scenario.
-
-
-Scenario: Creating a basic scenario with one argument
-  # The next step creates a macro(-step)
-  # The syntax of the new macro-step is specified between the double quotes.
-  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
-  # The macro argument is put between chevrons <...>.
-  Given I define the step "* I [log in\[\] as <userid>]" to mean:
-  """
-  Given I landed in the homepage
-  When I click "Sign in"
-  And I fill in "Username" with "<userid>"
-  And I fill in "Password" with "unguessable"
-  And I click "Submit"
-  """
-
-Scenario: Let's use the macro we created above
-  # Here the macro is invoked. Actual value for the argument is put between double quotes.
-  When I [log in\[\] as "guest"]
-
-  # The next step verifies that the steps from the macro were effectively executed.
-  Then I expect the following step trace:
-  """
-Invoked step: ... I landed in the homepage
-Invoked step: ... I click "Sign in"
-Invoked step: ... I fill in "Username" with "guest"
-Invoked step: ... I fill in "Password" with "unguessable"
-Invoked step: ... I click "Submit"
-  """

data/features/demo03.feature

@@ -1,53 +0,0 @@
-# File: demo03.feature
-
-Feature: Show the use of a basic macro with multiple arguments
-  As a Cuke user
-  So that I enjoy writing scenario.
-
-
-Scenario: defining basic macro with multiple arguments
-  # The next step creates a macro(-step)double quotes.
-  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
-  # The macro-step arguments are put between chevrons <...>.
-  Given I define the step "* I [enter my userid <userid> and password <password>]" to mean:
-  """
-  Given I landed in the homepage
-  When I click "Sign in"
-  And I fill in "Username" with "<userid>"
-  And I fill in "Password" with "<password>"
-  And I click "Submit"
-  """
-
-Scenario: Let's use the macro we created above
-  # Here the macro is invoked. Actual value for the argument is put between double quotes.
-  When I [enter my userid "guest" and password "unguessable"]
-
-  # The next step verifies that the steps from the macro were effectively executed.
-  Then I expect the following step trace:
-  """
-Invoked step: ... I landed in the homepage
-Invoked step: ... I click "Sign in"
-Invoked step: ... I fill in "Username" with "guest"
-Invoked step: ... I fill in "Password" with "unguessable"
-Invoked step: ... I click "Submit"
-  """
-
-Scenario: A macro invoking another macro (YES, it's possible!)
-  Given I define the step "* I [enter my credentials]" to mean:
-  """
-  # Notice that the next step is invoking the first macro above
-  When I [enter my userid "guest" and password "unguessable"]
-  """
-
-  # Invoking our lastly-created macro
-  When I [enter my credentials]
-
-  # Check that the nested macro still works
-  Then I expect the following step trace:
-  """
-Invoked step: ... I landed in the homepage
-Invoked step: ... I click "Sign in"
-Invoked step: ... I fill in "Username" with "guest"
-Invoked step: ... I fill in "Password" with "unguessable"
-Invoked step: ... I click "Submit"
-  """