cql 1.4.1 → 1.7.0

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

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

@@ -0,0 +1,35 @@
+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 "transform" do
+
+    describe "multiple targets" do
+
+      it 'does not apply more transforms than have been declared' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+        results = gs.query do
+          select :self, :self, :self
+          as thing1, thing2, thing3
+          from scenarios
+          transform :self => lambda { |thing1| 1 }
+          transform :self => lambda { |thing2| 2 }
+        end
+
+        expect(results.first).to include('thing1' => 1, 'thing2' => 2)
+        expect(results.first).to_not include('thing3' => 1)
+        expect(results.first).to_not include('thing3' => 2)
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,84 @@
+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 'with' do
+
+    it 'knows how to filter selections with certain qualities' do
+      expect(dsl_enabled_object).to respond_to(:with)
+    end
+
+
+    describe 'targeted' do
+
+      it 'can handle predefined filters' do
+        gs = CQL::Repository.new(CQL_FEATURE_FIXTURES_DIRECTORY)
+
+        expect {
+          gs.query do
+            select name
+            from features, scenarios, outlines
+            with scenarios => name(/test/)
+          end
+        }.to_not raise_error
+      end
+
+      it 'can handle a block filter' do
+        gs = CQL::Repository.new(CQL_FEATURE_FIXTURES_DIRECTORY)
+
+        expect {
+          gs.query do
+            select name
+            from features, scenarios, outlines
+            with scenarios => lambda { |scenario| true }
+          end
+        }.to_not raise_error
+      end
+
+      it 'correctly filters with a targeted block' do
+        gs = CQL::Repository.new(CQL_FEATURE_FIXTURES_DIRECTORY)
+
+        result = gs.query do
+          select name
+          from scenarios
+          with scenarios => lambda { |scenario| scenario.name =~ /king of/ }
+        end
+
+        expect(result).to eq([{'name' => 'The king of kings'}])
+      end
+
+      it 'can handle shorthand targets' do
+        gs = CQL::Repository.new(CQL_FEATURE_FIXTURES_DIRECTORY)
+
+        expect {
+          gs.query do
+            select name
+            from features, scenarios, outlines
+            with scenarios => name(/test/)
+          end
+        }.to_not raise_error
+      end
+
+      it 'can handle multiple targets' do
+        gs = CQL::Repository.new(CQL_FEATURE_FIXTURES_DIRECTORY)
+
+        expect {
+          gs.query do
+            select name
+            from features, scenarios, outlines
+            with scenarios => lambda { |scenario| true },
+                 outlines => lambda { |outline| true }
+          end
+        }.to_not raise_error
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,171 @@
+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 'without' do
+
+    it 'knows how to filter selections without certain qualities' do
+      expect(dsl_enabled_object).to respond_to(:without)
+    end
+
+    it 'correctly negates a block filter' do
+      gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+      negated_result = gs.query do
+        select name
+        from scenarios
+        with { |scenario| !(scenario.source_line == 3) }
+      end
+
+      without_result = gs.query do
+        select name
+        from scenarios
+        without { |scenario| scenario.source_line == 3 }
+      end
+
+      expect(without_result).to eq(negated_result)
+    end
+
+    it 'correctly negates a targeted filter' do
+      gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/simple")
+
+      negated_result = gs.query do
+        select :model
+        from features, scenarios
+        with scenarios => lambda { |scenario| false }
+      end
+
+      without_result = gs.query do
+        select :model
+        from features, scenarios
+        without scenarios => lambda { |scenario| true }
+      end
+
+      expect(without_result).to eq(negated_result)
+    end
+
+
+    describe 'negating predefined filters' do
+
+      it 'correctly negates a tag count filter' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/tags2")
+
+        negated_result = gs.query do
+          select :model
+          from scenarios
+          with tc lt 2
+        end
+
+        without_result = gs.query do
+          select :model
+          from scenarios
+          without tc gt 1
+        end
+
+        expect(without_result).to eq(negated_result)
+      end
+
+      it 'correctly negates a name filter' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/name_filter")
+
+        negated_result = gs.query do
+          select :model
+          from scenarios
+          with name /name[^1]/
+        end
+
+        without_result = gs.query do
+          select :model
+          from scenarios
+          without name /name1/
+        end
+
+        expect(without_result).to eq(negated_result)
+      end
+
+      it 'correctly negates a line filter' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/line_filter")
+
+        negated_result = gs.query do
+          select name
+          from scenarios
+          with line 'green eggs and ham'
+        end
+
+        without_result = gs.query do
+          select name
+          from scenarios
+          without line 'some other phrase'
+        end
+
+        expect(without_result).to eq(negated_result)
+      end
+
+      it 'correctly negates a tag filter' do
+        gs = CQL::Repository.new("#{CQL_FEATURE_FIXTURES_DIRECTORY}/scenario/tags3")
+
+        negated_result = gs.query do
+          select :model
+          from scenarios
+          with tags '@one'
+        end
+
+        without_result = gs.query do
+          select :model
+          from scenarios
+          without tags '@two'
+        end
+
+        expect(without_result).to eq(negated_result)
+      end
+
+    end
+
+    it 'correctly negates a targeted, predefined filter' do
+      gs = CQL::Repository.new(CQL_FEATURE_FIXTURES_DIRECTORY)
+
+      negated_result = gs.query do
+        select :model
+        from :all
+        with scenarios => name(/(?!test)/)
+      end
+
+      without_result = gs.query do
+        select :model
+        from :all
+        without scenarios => name(/test/)
+      end
+
+      expect(without_result).to eq(negated_result)
+    end
+
+    it 'correctly negates multiple filters' do
+      gs = CQL::Repository.new(CQL_FEATURE_FIXTURES_DIRECTORY)
+
+      negated_result = gs.query do
+        select :model
+        from :all
+        with scenarios => lambda { |scenario| false },
+             outlines => lambda { |outline| false }
+        with { |model| !model.is_a?(CukeModeler::Example) }
+      end
+
+      without_result = gs.query do
+        select :model
+        from :all
+        without scenarios => lambda { |scenario| true },
+                outlines => lambda { |outline| true }
+        without { |model| model.is_a?(CukeModeler::Example) }
+      end
+
+      expect(without_result).to eq(negated_result)
+    end
+
+  end
+
+end