cuke_modeler 0.4.1 → 1.0.0

data/features/modeling/example_output.feature

@@ -0,0 +1,39 @@
+Feature: Example output
+
+  An example model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting an example model
+    Given the following gherkin:
+      """
+      @tag1
+      @tag2 @tag3
+      Examples: an example with everything that it could have
+
+      Some description.
+      Some more description.
+
+      |param1|param2|
+      |value1|value2|
+      |value3|value4|
+      """
+    And an example model based on that gherkin
+      """
+        @model = CukeModeler::Example.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      @tag1 @tag2 @tag3
+      Examples: an example with everything that it could have
+
+      Some description.
+      Some more description.
+
+        | param1 | param2 |
+        | value1 | value2 |
+        | value3 | value4 |
+      """

data/features/modeling/feature_file_modeling.feature

@@ -0,0 +1,40 @@
+Feature: Feature file modeling
+
+
+  Feature file models represent a single .feature file in a test suite. They expose several attributes of the
+  feature file that they represent, as well as containing the model for the feature that is present in that file.
+
+
+  Background: An existing feature file
+    Given the directory "test_directory"
+    And the file "test_directory/foo.feature":
+      """
+      Feature: Bar
+      """
+    And the feature file is modeled
+      """
+        @model = CukeModeler::FeatureFile.new('<path_to>/test_directory/foo.feature')
+      """
+
+
+  Scenario: Modeling a feature files's path
+    When the feature file's path is requested
+      """
+        @model.path
+      """
+    Then the model returns "path_to/test_directory/foo.feature"
+
+  Scenario: Modeling a feature files's name
+    When the feature file's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "foo.feature"
+
+  Scenario: Modeling a feature file's feature
+    When the feature file's feature is requested
+      """
+        @model.feature
+      """
+    Then the model returns a model for the following feature:
+      | Bar |

data/features/modeling/feature_file_output.feature

@@ -0,0 +1,12 @@
+Feature: Feature file output
+
+  A feature file model's string output is simply the file path of the feature file that it models.
+
+
+  Scenario: Outputting a feature file model
+    Given a feature file model based on "some_feature_file.feature"
+    When it is outputted
+    Then the following text is provided:
+      """
+      <path_to>/some_feature_file.feature
+      """

data/features/modeling/feature_modeling.feature

@@ -0,0 +1,109 @@
+Feature: Feature modeling
+
+Feature models are the top level element of the gherkin portion of the model tree. They expose several attributes of
+the feature that they represent, as well as containing models for any background, scenarios, or outlines that are
+present in that feature.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      @tag_1 @tag_2
+      Feature: Feature Foo
+
+          Some feature description.
+
+        Some more.
+            And some more.
+
+        Background: The background
+          * some setup step
+
+        Scenario: Scenario 1
+          * a step
+
+        Scenario Outline: Outline 1
+          * a step
+        Examples:
+          | param |
+          | value |
+
+        Scenario: Scenario 2
+          * a step
+
+        Scenario Outline: Outline 2
+          * a step
+        Examples:
+          | param |
+          | value |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a feature's name
+    When the feature's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "Feature Foo"
+
+  Scenario: Modeling a feature's description
+    When the feature's description is requested
+      """
+        @model.description
+      """
+    Then the model returns
+      """
+        Some feature description.
+
+      Some more.
+          And some more.
+      """
+
+  Scenario: Modeling a feature's background
+    When the feature's background is requested
+      """
+        @model.background
+      """
+    Then the model returns a model for the background "The background"
+
+  Scenario: Modeling a feature's scenarios
+    When the feature's scenarios are requested
+      """
+        @model.scenarios
+      """
+    Then the model returns models for the following scenarios:
+      | Scenario 1 |
+      | Scenario 2 |
+
+  Scenario: Modeling a feature's outlines
+    When the feature's outlines are requested
+      """
+        @model.outlines
+      """
+    Then the model returns models for the following outlines:
+      | Outline 1 |
+      | Outline 2 |
+
+  Scenario: Modeling a feature's tags
+
+  Note: Although a feature does not inherit tags from anything else, they can still
+  be requested in the same manner as other models that have tags.
+
+    When the feature's tags are requested
+      """
+        @model.tags
+      """
+    Then the model returns models for the following tags:
+      | @tag_1 |
+      | @tag_2 |
+
+  Scenario: Modeling a feature's source line
+    When the feature's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "2"

data/features/modeling/feature_output.feature

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

data/features/modeling/model_output.feature

@@ -0,0 +1,22 @@
+Feature: Model output
+
+  All models can be output in text form. For models that represent parts of the file structure, this text
+  will be a path and for models that represent parts of a feature file, this text will be Gherkin (see the
+  model output documentation for specific models for details). As such, output from a model can be used as
+  input for the same kind of model.
+
+
+  Scenario: Outputting a model
+    Given the models provided by CukeModeler
+    Then  all of them can be output as text appropriate to the model type
+      """
+        model = <model_class>.new
+        
+        model.to_s
+      """
+    And the output can be used to make an equivalent model
+      """
+        model = <model_class>.new
+
+        <model_class>.new(model.to_s)
+      """

data/features/modeling/model_structure.feature

@@ -0,0 +1,48 @@
+Feature: Model structure
+
+When modeling an existing test suite, that suite is parsed and models are created for each element of the
+suite. These models form a nested structure of parent and child models which has the same shape as whatever
+portion of the suite that they represent (see the documentation for specific models for details).
+
+However, all models can also be used in an 'abstract' manner. That is, they can be created without any input
+(such as a file path or snippet of Gherkin) that would normally be used for determining their structure and
+properties. In these cases, their parent/child relationships and properties can be set directly rather than
+being populated dynamically based on an actual test suite.
+
+
+  Scenario: Creating abstract models
+    Given the models provided by CukeModeler
+    Then  all of them can be created without further context
+      """
+        abstract_model = <model_class>.new
+      """
+
+  Scenario: Nesting models
+    Given the models provided by CukeModeler
+    Then  all of them can contain other models
+      """
+        child_model = <model_class>.new
+        parent_model = <model_class>.new
+
+        parent_model.children << child_model
+      """
+    And   all of them can be contained inside of another model
+      """
+        child_model = <model_class>.new
+        parent_model = <model_class>.new
+
+        child_model.parent_model = parent_model
+      """
+
+  Scenario: Accessing the parsing data
+
+  Note: Directory and feature file models do not store any parsing data because parsing Gherkin source text
+  does not come into play until the feature level of modeling.
+
+    Given the models provided by CukeModeler
+    Then  all of them provide access to the parsing data that was used to create them
+      """
+        model = <model_class>.new(<source_text>)
+
+        model.parsing_data
+      """

data/features/modeling/outline_modeling.feature

@@ -0,0 +1,144 @@
+Feature: Outline modeling
+
+  Outline models represent a Scenario Outline portion of a feature. They expose several attributes of the outline
+  that they represent, as well as containing models for the steps, tags, and examples that are present in that outline.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      Scenario Outline: example outline
+
+          Some background description.
+
+        Some more.
+            Even more.
+
+
+          Given a <setup> step
+          When an action step
+          Then a <verification> step
+
+        Examples: example 1
+          | setup | verification |
+          | x     | y            |
+        Examples: example 2
+          | setup | verification |
+          | a     | b            |
+      """
+    And an outline model based on that gherkin
+      """
+        @model = CukeModeler::Outline.new(<source_text>)
+      """
+
+
+  Scenario: Modeling an outline's name
+    When the outline's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "example outline"
+
+  Scenario: Modeling an outline's description
+    When the outline's description is requested
+      """
+        @model.description
+      """
+    Then the model returns
+      """
+        Some background description.
+
+      Some more.
+          Even more.
+      """
+
+  Scenario: Modeling an outline's steps
+    When the outline'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 an outline's examples
+    When the outline's examples are requested
+      """
+        @model.examples
+      """
+    Then the model returns models for the following examples:
+      | example 1 |
+      | example 2 |
+
+  Scenario: Modeling an outline's tags
+    Given the following gherkin:
+      """
+      @feature_tag
+      Feature:
+
+        @outline_tag_1
+        @outline_tag_2
+        Scenario Outline:
+          Given a <setup> step
+          When an action step
+          Then a <verification> step
+
+        Examples:
+          | setup | verification |
+          | x     | y            |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the outline model of that feature model
+      """
+        @model = @model.outlines.first
+      """
+    When the outline's tags are requested
+      """
+        @model.tags
+      """
+    Then the model returns models for the following tags:
+      | @outline_tag_1 |
+      | @outline_tag_2 |
+    When the outline's inherited tags are requested
+      """
+        @model.applied_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag |
+    When all of the outline's tags are requested
+      """
+        @model.all_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag   |
+      | @outline_tag_1 |
+      | @outline_tag_2 |
+
+  Scenario: Modeling a outline's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario Outline:
+          * a step
+        Examples:
+          | param |
+          | value |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the outline model of that feature model
+      """
+        @model = @model.outlines.first
+      """
+    When the outline's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "3"