cql 1.4.2 → 1.5.0

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

@@ -1,7 +1,7 @@
 # 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).
+  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 (see corresponding documentation).
 
   Sample usage:
   ````
@@ -9,41 +9,12 @@ Feature: 'with' clause
     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 repository to query
     And the following feature has been modeled in the repository:
@@ -161,7 +132,7 @@ Feature: 'with' clause
       """
       select name
       from features, scenarios
-      with scenarios => tags('@tag_1','@tag_2')
+      with scenarios => lambda { |element| element.name == 'Test 1' }
       """
     Then the following values are returned:
       | name                             |
@@ -216,127 +187,6 @@ Feature: 'with' clause
       | 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:
       """
@@ -350,15 +200,3 @@ Feature: 'with' clause
       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
-      """

data/testing/cucumber/features/dsl.feature

@@ -56,25 +56,3 @@ Feature: DSL
       select 'name'
       from 'scenarios'
       """
-
-
-# Commented out so that they aren't picked up by Relish
-#
-#  @wip
-#  Scenario: Use 'order_by' to sort the results
-#
-#  # 'and' is a keyword. Some other kind of repeater word would be needed
-#  @wip
-#  Scenario: 'And' can be used instead of repeating the previous keyword
-#    When the following query is executed:
-#      """
-#      select 'name'
-#      and    'source_line'
-#      from CukeModeler::Scenario
-#      and  CukeModeler::Outline
-#      """
-#    Then the following values are returned:
-#      | name   | source_line |
-#      | Test 1 | 3           |
-#      | Test 2 | 6           |
-#      | Test 3 | 9           |

data/testing/cucumber/step_definitions/verification_steps.rb

@@ -2,16 +2,15 @@ Then(/^the following values are returned:$/) do |values|
   expected_keys = values.raw.first
   expected_results = values.hashes
 
+  # Protecting against false positives
+  # Key order doesn't matter and Ruby 1.8.7 does not retain hash key ordering, so sorting them for consistency
+  raise('Invalid result set. Attribute names cannot be repeated.') unless expected_keys.sort == expected_results.first.keys.sort
+
   expected_results.each do |result|
     result.each_pair { |key, value| result[key] = value.to_i if value =~ /^\d+$/ }
   end
 
-
-  @query_results.each_with_index do |result, index|
-    # Key order doesn't matter and Ruby 1.8.7 does not retain hash key ordering, so sorting them for consistency
-    expect(result.keys.sort).to eq(expected_keys.sort)
-    expect(result).to eq(expected_results[index])
-  end
+  expect(@query_results).to match_array(expected_results)
 end
 
 # Then(/^all of them can be queried for additional information$/) do

data/testing/model_helper.rb

@@ -0,0 +1,28 @@
+module CQL
+  module ModelHelper
+
+    def directory_with(*models)
+      directory_model = CukeModeler::Directory.new
+
+      models.each do |model|
+        case
+          when model.is_a?(CukeModeler::Feature)
+            file_model = CukeModeler::FeatureFile.new
+
+            if Gem.loaded_specs['cuke_modeler'].version.version[/^0/]
+              file_model.features = [model]
+            else
+              file_model.feature = model
+            end
+
+            directory_model.feature_files << file_model
+          else
+            raise(ArgumentError, "Don't know how to handle a '#{model.class}'")
+        end
+      end
+
+      directory_model
+    end
+
+  end
+end

data/testing/rspec/spec/clauses/as_clause_spec.rb

@@ -0,0 +1 @@
+#TODO - add some specs for the 'as' clause

data/testing/rspec/spec/clauses/from_clause_spec.rb

@@ -0,0 +1,146 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+
+describe 'an object that uses the DSL' do
+
+
+  let(:nodule) { CQL::Dsl }
+  let(:dsl_enabled_object) { Object.new.extend(nodule) }
+
+
+  describe "from" do
+
+    it 'knows from what to select attributes' do
+      expect(dsl_enabled_object).to respond_to(:from)
+    end
+
+    it 'selects from one or more things' do
+      expect(dsl_enabled_object.method(:from).arity).to eq(-1)
+    end
+
+    it "can handle an empty 'from' clause" do
+      gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+      result = gs.query do
+        select name
+        from
+      end
+
+      expect(result).to eq([])
+    end
+
+    describe "multiple targets" do
+
+      it 'raises an exception for inapplicable attributes' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        expect {
+          gs.query do
+            select name, steps
+            from features
+            from scenarios
+          end
+        }.to raise_error(ArgumentError)
+      end
+
+    end
+
+    describe 'shorthand' do
+
+      it 'should consider an exact match over a pluralization' do
+        plural_class_model = CukeModeler::CqlTestModels.new
+        singular_class_model = CukeModeler::CqlTestModel.new
+
+        plural_class_model.attribute_1 = 'plural'
+        singular_class_model.attribute_1 = 'singular'
+        plural_class_model.children << singular_class_model
+
+        repo = CQL::Repository.new(plural_class_model)
+
+        result = repo.query do
+          select attribute_1
+          from cql_test_model
+        end
+
+        expect(result.first['attribute_1']).to eq('singular')
+      end
+
+      it 'raises an exception if the shorthand form of a class cannot be mapped to a real class' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        expect {
+          gs.query do
+            select name
+            from not_a_real_class
+          end
+        }.to raise_error(ArgumentError, "Class 'CukeModeler::NotARealClass' does not exist")
+
+      end
+
+      it 'can freely mix shorthand and long-form names' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        # All long-form
+        base_result = gs.query do
+          select name
+          from CukeModeler::Scenario, CukeModeler::Feature
+        end
+
+        # All shorthand
+        expect(
+            gs.query do
+              select name
+              from scenarios, features
+            end
+        ).to eq(base_result)
+
+        # A mix of both
+        expect(
+            gs.query do
+              select name
+              from CukeModeler::Scenario, features
+            end
+        ).to eq(base_result)
+      end
+
+    end
+
+
+    describe 'special scopes' do
+
+      it 'understands the :all scope' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        expect { gs.query do
+          select :model
+          from :all
+        end
+        }.to_not raise_error
+      end
+
+      it 'queries from all models when scoped to :all' do
+        model_1 = CukeModeler::CqlTestModel.new
+        model_2 = CukeModeler::CqlTestModel.new
+        model_3 = CukeModeler::CqlTestModel.new
+
+        model_1.children << model_2
+        model_1.children << model_3
+
+        repo = CQL::Repository.new(model_1)
+
+        result = repo.query do
+          select :model
+          from :all
+        end
+
+        expect(result).to match_array([{:model => model_1},
+                                       {:model => model_2},
+                                       {:model => model_3}])
+      end
+
+    end
+
+  end
+
+
+end

data/testing/rspec/spec/clauses/select_clause_spec.rb

@@ -0,0 +1,184 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+
+describe 'an object that uses the DSL' do
+
+
+  let(:nodule) { CQL::Dsl }
+  let(:dsl_enabled_object) { Object.new.extend(nodule) }
+
+  describe "select" do
+
+    it 'knows how to select attributes' do
+      expect(dsl_enabled_object).to respond_to(:select)
+    end
+
+    it 'selects one or more attributes' do
+      expect(dsl_enabled_object.method(:select).arity).to eq(-1)
+    end
+
+    it 'correctly selects a single attribute from a model' do
+      model = CukeModeler::CqlTestModel.new
+      model.attribute_1 = 'foo'
+
+      repo = CQL::Repository.new(model)
+
+      result = repo.query do
+        select attribute_1
+        from cql_test_model
+      end
+
+
+      expect(result).to eq([{'attribute_1' => 'foo'}])
+    end
+
+    it 'correctly selects multiple attributes from a model' do
+      model = CukeModeler::CqlTestModel.new
+      model.attribute_1 = 'foo'
+      model.attribute_2 = 'bar'
+
+      repo = CQL::Repository.new(model)
+
+      result = repo.query do
+        select attribute_1, attribute_2
+        from cql_test_model
+      end
+
+
+      expect(result).to eq([{'attribute_1' => 'foo',
+                             'attribute_2' => 'bar'}])
+    end
+
+
+    describe 'special attributes' do
+
+      it 'understands the :model attribute' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        expect { gs.query do
+          select :model
+          from features
+        end
+        }.to_not raise_error
+      end
+
+      it 'interprets :model in the same manner that it interprets :self' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        self_result = gs.query do
+          select :self
+          from features
+        end
+
+        model_result = gs.query do
+          select :model
+          from features
+        end
+
+        # Only checking the values of the results because they will have different :model/:self keys
+        expect(model_result.collect { |result| result.values }).to eq(self_result.collect { |result| result.values })
+      end
+
+      it 'complains if an unknown special attribute is queried' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        expect {
+          gs.query do
+            select :foo
+            from scenarios
+          end
+        }.to raise_error(ArgumentError, ":foo is not a valid attribute for selection.")
+      end
+
+      it 'uses the :self attribute by default' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        default_result = gs.query do
+          select
+          from features
+        end
+
+        self_result = gs.query do
+          select :self
+          from features
+        end
+
+        expect(self_result).to eq(default_result)
+      end
+
+    end
+
+
+    it 'complains if an unknown normal attribute is queried' do
+      gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+      expect {
+        gs.query do
+          select steps
+          from features
+        end
+      }.to raise_error(ArgumentError, "'steps' is not a valid attribute for selection from a 'CukeModeler::Feature'.")
+    end
+
+
+    describe "multiple selections" do
+
+      it 'can freely mix empty selections and attribute selections' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        base_result = gs.query do
+          select :self
+          select name
+          select :self
+          as 'foo', 'bar', 'baz'
+          from scenarios
+        end
+
+
+        expect(
+            gs.query do
+              select
+              select name
+              select
+              as 'foo', 'bar', 'baz'
+              from scenarios
+            end
+        ).to eq(base_result)
+      end
+
+    end
+
+
+    describe 'duplicate selections' do
+
+      let(:warning_message) { "Multiple selections made without using an 'as' clause\n" }
+
+      it "warns if the same attribute is selected more than once without an 'as' clause being used" do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        expect {
+          gs.query do
+            select :model, :model, :model
+            from :all
+          end
+        }.to output(warning_message).to_stderr
+      end
+
+      it "does not warn if the same attribute is selected more than once and an 'as' clause is used" do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        expect {
+          gs.query do
+            select :model, :model, :model
+            # Usage of the clause is sufficient. Not going to try and count the mappings or anything like that.
+            as foo
+            from :all
+          end
+        }.to_not output(warning_message).to_stderr
+      end
+
+    end
+
+  end
+
+end