cql 1.2.1 → 1.3.0

data/testing/cucumber/features/clauses/from_clause.feature

@@ -0,0 +1,126 @@
+Feature: 'from' clause
+
+  The *from* clause specifies what type of models from which the *select* clause will gather its values. The *from* clause can take class objects defined in CukeModeler as well as shorthand versions thereof. The clause can also be given a special identifier in order to gather values from all models instead of specific model types.
+
+  The following are some example values:
+
+  CukeModeler::Outline  (exact class)
+  outline               (singular)
+  outlines              (pluralized)
+
+    Sample usage:
+      cql_repo.query do
+        select name
+        from scenarios
+      end
+
+  This clause can be repeated multiple times. The arguments for successive clauses are simply added to the previous arguments.
+
+
+  Background: A sample Cucumber suite
+    Given a directory "test_directory"
+    And a file "test_directory/test_file_1.feature":
+      """
+      Feature: A test feature
+
+        Scenario: Test 1
+          * some steps
+
+        @special_tag
+        Scenario: Test 2
+          * some other steps
+
+        Scenario Outline: Test 3
+          * some steps
+        Examples: First examples
+          | param |
+          | value |
+        Examples: Second examples
+          | param |
+          | value |
+      """
+    And a repository is made from "test_directory"
+
+
+  Scenario: Using 'from' to specify what kind of objects from which to return attributes
+    When the following query is executed:
+      """
+      select name
+      from scenarios
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 1 |
+      | Test 2 |
+    When the following query is executed:
+      """
+      select name
+      from outlines
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 3 |
+
+  Scenario: Gathering from multiple sources
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 1 |
+      | Test 2 |
+      | Test 3 |
+
+  Scenario: Using the shorthand form of class names
+    When the following query is executed:
+      """
+      select name
+      from CukeModeler::Scenario
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name
+      from scenario
+      """
+    And the result is the same as the result of the following query:
+      """
+      select name
+      from scenarios
+      """
+
+  Scenario: Using the 'from' clause multiple times
+
+  Note: Selecting from different types of model should be done with care since problems can occur if the attributes specified by the 'select' clause do not exist on all of the models specified by the 'from' clause
+
+    When the following query is executed:
+      """
+      select name
+      from scenarios
+      from outlines
+      """
+    And the result is the same as the result of the following query:
+      """
+      select name
+      from scenarios, outlines
+      """
+
+  Scenario: Gathering from everything
+
+  Note: Very few selections will be applicable for all models
+
+    When the following query is executed:
+      """
+      select :model
+      from :all
+      """
+    Then all models are queried from
+
+
+# Commented out so that they aren't picked up by Relish
+#  @wip
+#  Scenario: Can 'from' from all type of model
+#
+#  @wip
+#  Scenario: From-ing from a collection

data/testing/cucumber/features/clauses/select_clause.feature

@@ -0,0 +1,117 @@
+Feature: 'select' clause
+
+  The *select* clause specifies what attributes will be retrieved from the models specified by the *from* clause. Multiple values can be given and they are delimited by a comma. The *select* clause can take any method to which the objects specified by *from* know how to respond. The clause can also be given a special identifier in order to return the underlying models themselves instead of their attributes. If no attributes are specified then the underlying model will be returned instead, just as if the special identifier had been used (it is simply an alternate syntax and may look nicer in some queries).
+
+    Sample usage:
+      cql_repo.query do
+        select name, tags, description_text
+        from features
+      end
+
+  This clause can be repeated multiple times. The arguments for successive clauses are simply added to the previous arguments.
+
+
+  Background: A sample Cucumber suite
+    Given a directory "test_directory"
+    And a file "test_directory/test_file_1.feature":
+      """
+      Feature: A test feature
+
+        Scenario: Test 1
+          * some steps
+
+        @special_tag
+        Scenario: Test 2
+          * some other steps
+
+        Scenario Outline: Test 3
+          * some steps
+        Examples: First examples
+          | param |
+          | value |
+        Examples: Second examples
+          | param |
+          | value |
+      """
+    And a repository is made from "test_directory"
+
+
+  Scenario: Using 'select' to specify which attributes of an object to return
+    When the following query is executed:
+      """
+      select name
+      from scenarios
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 1 |
+      | Test 2 |
+
+  Scenario: Selection of multiple attributes
+    When the following query is executed:
+      """
+      select name, source_line
+      from scenarios
+      """
+    Then the following values are returned:
+      | name   | source_line |
+      | Test 1 | 3           |
+      | Test 2 | 7           |
+
+  Scenario: Selection of the same attribute multiple times
+    When the following query is executed:
+      """
+      select name, name
+      from scenarios
+      """
+    Then the following values are returned:
+      | name   | name   |
+      | Test 1 | Test 1 |
+      | Test 2 | Test 2 |
+
+  Scenario: Selection of the underlying models
+
+  Note: There is no difference between the two different special identifiers. They are merely aliases for each other.
+
+    When the following query is executed:
+      """
+      select :self
+      from scenarios
+      """
+    Then the models for the following items are returned:
+      | Test 1 |
+      | Test 2 |
+    And equivalent results are returned for the following query:
+      """
+      select :model
+      from scenarios
+      """
+
+  Scenario: Repetitive selection
+    When the following query is executed:
+      """
+      select name
+      select source_line
+      from scenarios
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name, source_line
+      from scenarios
+      """
+
+  Scenario: Default selection
+    When the following query is executed:
+      """
+      select
+      from scenarios
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select :self
+      from scenarios
+      """
+
+# Commented out so that they aren't picked up by Relish
+#  @wip
+#  Scenario: Can select from all types of model

data/testing/cucumber/features/clauses/transform_clause.feature

@@ -0,0 +1,153 @@
+Feature: 'transform' clause
+
+  The *transform* clause allows you to change the values of the attributes specified by the *select* clause after they are gathered. Value transforming can be done as a list of transformation blocks that are applied in order or as a mapping of specific keys and their transformations.
+
+    Sample usage:
+      cql_repo.query do
+        select name
+        transform { |name| name.upcase }
+        from features
+      end
+
+  This will return a list of all of the feature names but with all of their names upcased.
+
+  This clause can be repeated multiple times. When using lists of transforms, the arguments for successive clauses are simply added to the previous arguments. When using mapped transforms, the mappings are likewise combined. If the same key is mapped more than once, the mappings are tracked separately such that they can be applied to different instances of attribute retrieval (see examples below).
+
+  Background: A sample Cucumber suite
+    Given a directory "test_directory"
+    And a file "test_directory/test_file_1.feature":
+      """
+      Feature: A test feature
+
+        Scenario: Test 1
+          * some steps
+
+        @special_tag
+        Scenario: Test 2
+          * some other steps
+
+        Scenario Outline: Test 3
+          * some steps
+        Examples: First examples
+          | param |
+          | value |
+        Examples: Second examples
+          | param |
+          | value |
+      """
+    And a repository is made from "test_directory"
+
+
+  Scenario: Using 'transform' to change values after they are gathered
+    When the following query is executed:
+      """
+      select name
+      transform lambda { |name| name.upcase }
+      from scenarios, outlines
+      """
+    Then the following values are returned:
+      | name   |
+      | TEST 1 |
+      | TEST 2 |
+      | TEST 3 |
+
+  Scenario: Single transformation shorthand
+    When the following query is executed:
+      """
+      select name
+      transform { |name| name.upcase }
+      from scenarios, outlines
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name
+      transform lambda { |name| name.upcase }
+      from scenarios, outlines
+      """
+
+  Scenario: Transformation of multiple values
+    When the following query is executed:
+      """
+      select name, tags
+      transform lambda{ |name| name.upcase },
+                lambda{ |tags| 9 }
+      from scenarios, outlines
+      """
+    Then the following values are returned:
+      | name   | tags |
+      | TEST 1 | 9    |
+      | TEST 2 | 9    |
+      | TEST 3 | 9    |
+
+  Scenario: Selectively transforming attributes
+    When the following query is executed:
+      """
+      select name, tags
+      transform tags => lambda{ |tags| 9 }
+      from scenarios, outlines
+      """
+    Then the following values are returned:
+      | name   | tags |
+      | Test 1 | 9    |
+      | Test 2 | 9    |
+      | Test 3 | 9    |
+
+  Scenario: Using the 'transform' clause multiple times
+    When the following query is executed:
+      """
+      select name, tags
+      transform { |name| name.upcase }
+      transform { |tags| 9 }
+      from scenarios, outlines
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name, tags
+      transform lambda { |name| name.upcase },
+                lambda { |tags| 9 }
+      from scenarios, outlines
+      """
+    When the following query is executed:
+      """
+      select name, tags
+      transform name => lambda { |name| name.upcase }
+      transform tags => lambda { |tags| 9 }
+      from scenarios, outlines
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name, tags
+      transform name => lambda { |name| name.upcase },
+                tags => lambda { |tags| 9 }
+      from scenarios, outlines
+      """
+
+  Scenario: Transforming duplicate attributes
+
+  Sometimes you may want to select the same attribute multiple times and perform multiple different transformations on it. This can be done with both set transforming and selective transforming.
+
+    When the following query is executed:
+      """
+      select name, tags, name
+      transform lambda { |name| name.upcase },
+                lambda { |tags| 9 },
+                lambda { |name| name.downcase }
+      from scenarios, outlines
+      """
+    Then the following values are returned:
+      | name   | tags | name   |
+      | TEST 1 | 9    | test 1 |
+      | TEST 2 | 9    | test 2 |
+      | TEST 3 | 9    | test 3 |
+    When the following query is executed:
+      """
+      select name, source_line, name
+      transform name => lambda { |name| name.upcase }
+      transform name => lambda { |name| name.downcase }
+      from scenarios, outlines
+      """
+    Then the following values are returned:
+      | name   | source_line | name   |
+      | TEST 1 | 3           | test 1 |
+      | TEST 2 | 7           | test 2 |
+      | TEST 3 | 10          | test 3 |

data/testing/cucumber/features/clauses/with_clause.feature

@@ -0,0 +1,363 @@
+# todo - Rewrite the scenarios such that they use their own test specific feature files instead of setting up a large suite in the background
+Feature: 'with' clause
+
+  The *with* clause specifies filter conditions that will reduce the number of things targeted by the *from* clause. The *with* clause can take one or more blocks that will filter out any object for which the block does not evaluate to true (using 'without' instead of 'with' will have the opposite effect). Alternatively, mappings of specific *from* targets to their respective filtering blocks can be provided. The *with* clause can also take predefined filters (detailed below).
+
+    Sample usage:
+      cql_repo.query do
+        select name, tags, description_text
+        from features
+        with { |feature| feature.name =~ /foo/ }
+        with tc lt 3
+      end
+
+  This clause can be repeated multiple times. The arguments for successive clauses are simply added to the previous arguments.
+
+
+  The following filters are supported for models that have tags:
+
+  * tags - Filters out models that do not have the exact set of tags provided.
+  * tc   - (tag count) Filters out models based on the number of tags that they have.
+
+  The following filters are supported for models that have names:
+
+  * name - Filters out models whose name does not match the name provided. Can be a string or regular expression.
+
+  The following filters are supported for models that have steps:
+
+  * line - Filters out models whose steps do not include the provided step (keywords and blocks are ignored). Can be a string or regular expression.
+  * lc   - (line count) Filters out models based on the number of steps that they have.
+
+  The following filters are supported for feature models:
+
+  * sc   - (scenario count) Filters out models based on the number of scenarios that they have.
+  * soc  - (scenario outline count) Filters out models based on the number of outlines that they have.
+  * ssoc - (scenario and scenario outline count) Filters out models based on the total number of scenarios and outlines that they have.
+
+  For count based filters, the following operators are available:
+
+  * lt   (Less than)
+  * lte  (Less than or equals)
+  * gt   (Greater than)
+  * gte  (Greater than or equals)
+
+
+  Background: A sample Cucumber suite
+    Given a directory "test_directory"
+    And a file "test_directory/test_file_1.feature":
+      """
+      Feature: A test feature
+
+        @tag_1 @tag_2
+        Scenario: Test 1
+          * some steps
+
+        @special_tag @tag_2
+        Scenario: Test 2
+          * some other steps
+
+        @a @b @c
+        Scenario Outline: Test 3
+          * some steps
+          * some more steps
+        Examples: First examples
+          | param |
+          | value |
+        Examples: Second examples
+          | param |
+          | value |
+      """
+    And a file "test_directory/test_file_2.feature":
+      """
+      Feature: A feature with lots of scenarios
+
+        Scenario: 1
+          * different steps
+
+        Scenario: 2
+          * different steps
+
+        Scenario: 3
+          * different steps
+      """
+    And a file "test_directory/test_file_3.feature":
+      """
+      Feature: A feature with lots of outlines
+
+        Scenario Outline: 1
+          * different steps
+        Examples:
+          | param |
+          | value |
+
+        Scenario Outline: 2
+          * different steps
+        Examples:
+          | param |
+          | value |
+
+        Scenario Outline: 3
+          * different steps
+        Examples:
+          | param |
+          | value |
+      """
+    And a file "test_directory/test_file_4.feature":
+      """
+      Feature: A feature with a mix of tests
+
+        Scenario: 4
+          * different steps
+
+        Scenario Outline: 4
+          * different steps
+        Examples:
+          | param |
+          | value |
+      """
+    And a repository is made from "test_directory"
+
+
+  Scenario: Using 'with' to limit the objects from which to return attributes
+    When the following query is executed:
+      """
+      select name
+      from scenarios
+      with lambda { |scenario| scenario.source_line == 8 }
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 2 |
+
+  Scenario: Single filter shorthand
+    When the following query is executed:
+      """
+      select name
+      from scenarios
+      with { |scenario| scenario.tags.include?('@special_tag') }
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name
+      from scenarios
+      with lambda { |scenario| scenario.tags.include?('@special_tag') }
+      """
+
+  Scenario: Using multiple filters
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines, examples
+      with lambda { |element| element.is_a?(CukeModeler::Example) },
+           lambda { |element| element.name =~ /Second/ }
+      """
+    Then the following values are returned:
+      | name            |
+      | Second examples |
+
+  Scenario: Selectively filtering models
+    When the following query is executed:
+      """
+      select name
+      from features, scenarios
+      with scenarios => tags('@tag_1','@tag_2')
+      """
+    Then the following values are returned:
+      | name                             |
+      | A test feature                   |
+      | A feature with lots of scenarios |
+      | A feature with lots of outlines  |
+      | A feature with a mix of tests    |
+      | Test 1                           |
+
+  Scenario: Using the 'with' clause multiple times
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines, examples
+      with { |element| element.is_a?(CukeModeler::Example) }
+      with { |element| element.name =~ /Second/ }
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name
+      from scenarios, outlines, examples
+      with lambda { |element| element.is_a?(CukeModeler::Example) },
+           lambda { |element| element.name =~ /Second/ }
+      """
+    When the following query is executed:
+      """
+      select name
+      from features, scenarios
+      with scenarios => lambda { |scenario| scenario.tags.include?('@tag_1') }
+      with scenarios => lambda { |scenario| scenario.tags.include?('@tag_2') }
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name
+      from features, scenarios
+      with({ scenarios => lambda { |scenario| scenario.tags.include?('@tag_1') }},
+           { scenarios => lambda { |scenario| scenario.tags.include?('@tag_2') }})
+      """
+
+  Scenario: Mixing targeted and blanket filters
+    When the following query is executed:
+      """
+      select name
+      from examples, features
+      with { |element| element.name != '' }
+      with features => lambda { |feature| feature.name =~ /lots/ }
+      """
+    Then the following values are returned:
+      | name                             |
+      | First examples                   |
+      | Second examples                  |
+      | A feature with lots of scenarios |
+      | A feature with lots of outlines  |
+
+# todo - break out the predefined filters into another feature file?
+  Scenario: Filtering by tags
+    When the following query is executed:
+      """
+      select name
+      from scenarios
+      with tags '@tag_1', '@tag_2'
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 1 |
+
+  Scenario: Filtering by tag count
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines
+      with tc gt 2
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 3 |
+
+  Scenario: Filtering by name
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines
+      with name 'Test 3'
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 3 |
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines
+      with name /Test [12]/
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 1 |
+      | Test 2 |
+
+  Scenario: Filtering by line
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines
+      with line 'some steps'
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 1 |
+      | Test 3 |
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines
+      with line /other/
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 2 |
+
+  Scenario: Filtering by line count
+    When the following query is executed:
+      """
+      select name
+      from scenarios, outlines
+      with lc gt 1
+      """
+    Then the following values are returned:
+      | name   |
+      | Test 3 |
+
+  Scenario: Filtering by scenario count
+    When the following query is executed:
+      """
+      select name
+      from features
+      with sc gt 2
+      """
+    Then the following values are returned:
+      | name                             |
+      | A feature with lots of scenarios |
+
+  Scenario: Filtering by outline count
+    When the following query is executed:
+      """
+      select name
+      from features
+      with soc gt 2
+      """
+    Then the following values are returned:
+      | name                            |
+      | A feature with lots of outlines |
+
+  Scenario: Filtering by combined test count
+    When the following query is executed:
+      """
+      select name
+      from features
+      with ssoc lt 3
+      """
+    Then the following values are returned:
+      | name                          |
+      | A feature with a mix of tests |
+
+  @wip
+  Scenario: Using the 'lt' count filter
+
+  @wip
+  Scenario: Using the 'lte' count filter
+
+  @wip
+  Scenario: Using the 'gt' count filter
+
+  @wip
+  Scenario: Using the 'gte' count filter
+
+  Scenario: Using 'without' for negation
+    When the following query is executed:
+      """
+      select name
+      from scenarios
+      without { |scenario| scenario.source_line == 8 }
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name
+      from scenarios
+      with { |scenario| !(scenario.source_line == 8) }
+      """
+    When the following query is executed:
+      """
+      select name
+      from features
+      without ssoc lt 3
+      """
+    Then the result is the same as the result of the following query:
+      """
+      select name
+      from features
+      with ssoc gt 2
+      """