cuke_modeler 0.4.1 → 1.0.0

data/features/modeling/outline_output.feature

@@ -0,0 +1,69 @@
+Feature: Outline output
+
+  An outline model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting an outline model
+    Given the following gherkin:
+      """
+      @tag1@tag2
+      @tag3
+      Scenario Outline: An outline with everything that it could have
+
+      Some description.
+      Some more description.
+
+      * a step
+      |value|
+      * a <value> step
+      \"\"\"
+        some string
+      \"\"\"
+
+      Examples:
+      Some description.
+      Some more description.
+      | value |
+      | x     |
+      @example_tag
+
+      Examples:
+      | value |
+      | y     |
+      """
+    And an outline model based on that gherkin
+      """
+        @model = CukeModeler::Outline.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      @tag1 @tag2 @tag3
+      Scenario Outline: An outline with everything that it could have
+
+      Some description.
+      Some more description.
+
+        * a step
+          | value |
+        * a <value> step
+          \"\"\"
+            some string
+          \"\"\"
+
+      Examples:
+
+      Some description.
+      Some more description.
+
+        | value |
+        | x     |
+
+      @example_tag
+      Examples:
+        | value |
+        | y     |
+      """

data/features/modeling/row_modeling.feature

@@ -0,0 +1,48 @@
+Feature: Row modeling
+
+  Row models represent an individual row in a step or example table. They expose several attributes of the row
+  that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      | foo | bar |
+      """
+    And a row model based on that gherkin
+      """
+        @model = CukeModeler::Row.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a rows's cells
+    When the rows's cells are requested
+      """
+        @model.cells
+      """
+    Then the model returns models for the following cells:
+      | foo |
+      | bar |
+
+  Scenario: Modeling a row's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario:
+          * a step
+            | foo |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the row model inside of that feature model
+      """
+        @model = @model.tests.first.steps.first.block.rows.first
+      """
+    When the rows's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "5"

data/features/modeling/row_output.feature

@@ -0,0 +1,22 @@
+Feature: Row output
+
+  A row model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting a row model
+    Given the following gherkin:
+      """
+      |foo|bar|
+      """
+    And a row model based on that gherkin
+      """
+        @model = CukeModeler::Row.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      | foo | bar |
+      """

data/features/modeling/scenario_modeling.feature

@@ -0,0 +1,118 @@
+Feature: Scenario modeling
+
+  Scenario models represent a Scenario portion of a feature. They expose several attributes of the scenario
+  that they represent, as well as containing models for the steps and tags that are present in that scenario.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      Scenario: example scenario
+
+          Some background description.
+
+        Some more.
+            Even more.
+
+        Given a setup step
+        When an action step
+        Then a verification step
+      """
+    And a scenario model based on that gherkin
+      """
+        @model = CukeModeler::Scenario.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a scenario's name
+    When the scenario's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "example scenario"
+
+  Scenario: Modeling a scenario's description
+    When the scenario's description is requested
+      """
+        @model.description
+      """
+    Then the model returns
+      """
+        Some background description.
+
+      Some more.
+          Even more.
+      """
+
+  Scenario: Modeling a scenario's steps
+    When the scenario's steps are requested
+      """
+        @model.steps
+      """
+    Then the model returns models for the following steps:
+      | a setup step        |
+      | an action step      |
+      | a verification step |
+
+  Scenario: Modeling a scenario's tags
+    Given the following gherkin:
+      """
+      @feature_tag
+      Feature:
+
+        @scenario_tag_1
+        @scenario_tag_2
+        Scenario:
+          * a step
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the scenario model of that feature model
+      """
+        @model = @model.scenarios.first
+      """
+    When the scenario's tags are requested
+      """
+        @model.tags
+      """
+    Then the model returns models for the following tags:
+      | @scenario_tag_1 |
+      | @scenario_tag_2 |
+    When the scenario's inherited tags are requested
+      """
+        @model.applied_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag |
+    When all of the scenario's tags are requested
+      """
+        @model.all_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag    |
+      | @scenario_tag_1 |
+      | @scenario_tag_2 |
+
+  Scenario: Modeling a scenario's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario:
+          * a step
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the scenario model of that feature model
+      """
+        @model = @model.scenarios.first
+      """
+    When the scenario's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "3"

data/features/modeling/scenario_output.feature

@@ -0,0 +1,45 @@
+Feature: Scenario output
+
+  A scenario model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting a scenario model
+    Given the following gherkin:
+      """
+      @tag1@tag2
+      @tag3
+      Scenario: A scenario with everything that it could have
+
+      Including a description
+      and then some.
+
+      * a step
+      |value|
+      * another step
+      \"\"\"
+        some string
+      \"\"\"
+      """
+    And a scenario model based on that gherkin
+      """
+        @model = CukeModeler::Scenario.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      @tag1 @tag2 @tag3
+      Scenario: A scenario with everything that it could have
+
+      Including a description
+      and then some.
+
+        * a step
+          | value |
+        * another step
+          \"\"\"
+            some string
+          \"\"\"
+      """

data/features/modeling/step_modeling.feature

@@ -0,0 +1,84 @@
+Feature: Step modeling
+
+  Step models represent represent the a step in a scenario, outline, or background. They expose several attributes
+  of the step that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      * a step
+      """
+    And a step model based on that gherkin
+      """
+        @model = CukeModeler::Step.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a step's keyword
+    When the step's keyword is requested
+      """
+        @model.keyword
+      """
+    Then the model returns "*"
+
+  Scenario: Modeling a step's base text
+    When the step's base text is requested
+      """
+        @model.text
+      """
+    Then the model returns "a step"
+
+  Scenario: Modeling a step's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario:
+          * a step
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the step model inside of that feature model
+      """
+        @model = @model.tests.first.steps.first
+      """
+    When the step's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "4"
+
+  Scenario: Modeling a step's table
+    Given a step model based on the following gherkin:
+      """
+      * a step
+        | value 1 |
+        | value 2 |
+      """
+    When the step's table is requested
+      """
+        @model.block
+      """
+    Then the model returns a model for the following table:
+      | value 1 |
+      | value 2 |
+
+  Scenario: Modeling a step's doc string
+    Given a step model based on the following gherkin:
+      """
+      * a step
+        \"\"\"
+        some text
+        \"\"\"
+      """
+    When the step's doc string is requested
+      """
+        @model.block
+      """
+    Then the model returns a model for the following doc string:
+      """
+      some text
+      """

data/features/modeling/step_output.feature

@@ -0,0 +1,29 @@
+Feature: Step output
+
+  A step model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting a step model
+
+  Note: Outputting a step that has a doc string is accomplished in the same manner
+
+    Given the following gherkin:
+      """
+      * a step
+        |value1|
+        |value2|
+      """
+    And a step model based on that gherkin
+      """
+        @model = CukeModeler::Step.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      * a step
+        | value1 |
+        | value2 |
+      """

data/features/modeling/table_modeling.feature

@@ -0,0 +1,50 @@
+Feature: Table modeling
+
+  Table models represent represent the table argument to a step. They expose several attributes of the table
+  that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      | value 1 | value 2 |
+      | value 3 | value 4 |
+      """
+    And a table model based on that gherkin
+      """
+        @model = CukeModeler::Table.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a table's rows
+    When the table's rows are requested
+      """
+        @model.rows
+      """
+    Then the model returns models for the following rows:
+      | value 1 | value 2 |
+      | value 3 | value 4 |
+
+  Scenario: Modeling a table's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario:
+          * a step
+            | value 1 |
+            | value 2 |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the table model inside of that feature model
+      """
+        @model = @model.tests.first.steps.first.block
+      """
+    When the table's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "5"