cuke_modeler 0.4.1 → 1.0.0

data/features/modeling/background_modeling.feature

@@ -0,0 +1,77 @@
+Feature: Background modeling
+
+  Background models represent the Background portion of a feature. They expose several attributes of the background
+  that they represent, as well as containing models for the steps that are present in that background.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      Background: Some general test setup stuff.
+
+          Some background description.
+
+        Some more.
+            Even more.
+
+        Given a setup step
+        And another setup step
+        When an action step
+      """
+    And a background model based on that gherkin
+      """
+        @model = CukeModeler::Background.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a backgrounds's name
+    When the background's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "Some general test setup stuff."
+
+  Scenario: Modeling a backgrounds's description
+    When the background's description is requested
+      """
+        @model.description
+      """
+    Then the model returns
+      """
+        Some background description.
+
+      Some more.
+          Even more.
+      """
+
+  Scenario: Modeling a backgrounds's steps
+    When the background's steps are requested
+      """
+        @model.steps
+      """
+    Then the model returns models for the following steps:
+      | a setup step       |
+      | another setup step |
+      | an action step     |
+
+  Scenario: Modeling a backgrounds's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Background:
+          * a step
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the background model of that feature model
+      """
+        @model = @model.background
+      """
+    When the background's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "3"

data/features/modeling/background_output.feature

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

data/features/modeling/cell_modeling.feature

@@ -0,0 +1,23 @@
+Feature: Cell modeling
+
+  Cell models represent an individual cell in a table row (either a step table or an example table). They expose
+  several attributes of the cell that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      foo
+      """
+    And a cell model based on that gherkin
+      """
+        @model = CukeModeler::Cell.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a cell's value
+    When the cell's value is requested
+      """
+        @model.value
+      """
+    Then the model returns "foo"

data/features/modeling/cell_output.feature

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

data/features/modeling/directory_modeling.feature

@@ -0,0 +1,65 @@
+Feature: Directory modeling
+
+
+  Directory models are the top level element of a model tree. They expose several attributes of the directory that they
+  represent, as well as containing models for any feature files or subdirectories that are present in the directory
+  that they represent.
+
+
+  Background: An existing test suite
+    Given the directory "test_directory"
+    And the file "test_directory/test_file_1.feature"
+    And the file "test_directory/test_file_2.feature"
+    And the file "test_directory/random.file"
+    And the directory "test_directory/nested_directory"
+
+
+  Scenario: Modeling a directory's path
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's path is requested
+      """
+        @model.path
+      """
+    Then the model returns "path_to/test_directory"
+
+  Scenario: Modeling a directory's name
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "test_directory"
+
+  Scenario: Modeling a directory's feature files
+
+  Note: Files that are not .feature files are not modeled
+
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's feature files are requested
+      """
+        @model.feature_files
+      """
+    Then the model returns models for the following feature files:
+      | test_file_1.feature |
+      | test_file_2.feature |
+
+  Scenario: Modeling a directory's directories
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's directories are requested
+      """
+        @model.directories
+      """
+    Then the model returns models for the following directories:
+      | nested_directory |

data/features/modeling/directory_output.feature

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

data/features/modeling/doc_string_modeling.feature

@@ -0,0 +1,61 @@
+Feature: Doc string modeling
+
+
+  Doc string models represent the doc string argument to a step. They expose several attributes of the doc string
+  that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      \"\"\" type foo
+      content bar
+      \"\"\"
+      """
+    And a doc string model based on that gherkin
+      """
+        @model = CukeModeler::DocString.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a doc string's content type
+    When the doc string's name is requested
+      """
+        @model.content_type
+      """
+    Then the model returns "type foo"
+
+  Scenario: Modeling a doc string's content
+    When the doc string's content is requested
+      """
+        @model.content
+      """
+    Then the model returns
+      """
+      content bar
+      """
+
+  Scenario: Modeling a doc string'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 doc string model inside of that feature model
+      """
+        @model = @model.tests.first.steps.first.block
+      """
+    When the doc string's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "5"

data/features/modeling/doc_string_output.feature

@@ -0,0 +1,32 @@
+Feature: Doc string output
+
+  A doc string model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting a doc string model
+    Given the following gherkin:
+      """
+      \"\"\" type foo
+      Some text
+
+        some more text
+
+      \"\"\"
+      """
+    And a doc string model based on that gherkin
+      """
+        @model = CukeModeler::DocString.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      \"\"\" type foo
+      Some text
+
+        some more text
+
+      \"\"\"
+      """

data/features/modeling/example_modeling.feature

@@ -0,0 +1,125 @@
+Feature: Example modeling
+
+  Example models represent an example table of a Scenario Outline portion of a feature. They expose
+  several attributes of the example that they represent, as well as containing models for the example
+  rows and tags that are present in that example.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      @a_tag
+      Examples: test example
+
+          Some example description.
+
+        Some more.
+            Even more.
+
+        | param 1 | param 2 |
+        | value 1 | value 2 |
+      """
+    And an example model based on that gherkin
+      """
+        @model = CukeModeler::Example.new(<source_text>)
+      """
+
+
+  Scenario: Modeling an example's name
+    When the example's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "test example"
+
+  Scenario: Modeling an example's description
+    When the example's description is requested
+      """
+        @model.description
+      """
+    Then the model returns
+      """
+        Some example description.
+
+      Some more.
+          Even more.
+      """
+
+  Scenario: Modeling an example's rows
+    When the example's rows are requested
+      """
+        @model.rows
+      """
+    Then the model returns models for the following rows:
+      | param 1 | param 2 |
+      | value 1 | value 2 |
+
+  Scenario: Modeling an example's tags
+    Given the following gherkin:
+      """
+      @feature_tag
+      Feature:
+
+        @outline_tag
+        Scenario Outline:
+          * a step
+
+        @example_tag
+        Examples:
+          | param |
+          | value |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the example model inside of that feature model
+      """
+        @model = @model.tests.first.examples.first
+      """
+    When the example's tags are requested
+      """
+        @model.tags
+      """
+    Then the model returns models for the following tags:
+      | @example_tag |
+    When the example's inherited tags are requested
+      """
+        @model.applied_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag |
+      | @outline_tag |
+    When all of the example's tags are requested
+      """
+        @model.all_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag |
+      | @outline_tag |
+      | @example_tag |
+
+  Scenario: Modeling an example'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 example model inside of that feature model
+      """
+        @model = @model.tests.first.examples.first
+      """
+    When the example's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "5"