cucumber-core 1.1.3 → 1.2.0

data/lib/cucumber/core/test/runner.rb

@@ -97,6 +97,8 @@ module Cucumber
 
               def execute(test_step, monitor, &continue)
                 result = test_step.execute(monitor.result, &continue)
+                result = result.with_message(%(Undefined step: "#{test_step.name}")) if result.undefined?
+                result = result.with_appended_backtrace(test_step.source.last) if test_step.respond_to?(:source)
                 result.describe_to(monitor, result)
               end
 

data/lib/cucumber/core/test/step.rb

@@ -7,7 +7,7 @@ module Cucumber
       class Step
         attr_reader :source
 
-        def initialize(source, action = Test::UndefinedAction.new)
+        def initialize(source, action = Test::UndefinedAction.new(source.last.location))
           raise ArgumentError if source.any?(&:nil?)
           @source, @action = source, action
         end
@@ -31,8 +31,8 @@ module Cucumber
           @action.execute(*args)
         end
 
-        def with_action(&block)
-          self.class.new(source, Test::Action.new(&block))
+        def with_action(location = nil, &block)
+          self.class.new(source, Test::Action.new(location, &block))
         end
 
         def name
@@ -43,6 +43,10 @@ module Cucumber
           source.last.location
         end
 
+        def action_location
+          @action.location
+        end
+
         def match_locations?(queried_locations)
           return true if queried_locations.include? location
           source.any? { |s| s.match_locations?(queried_locations) }

data/lib/cucumber/core/version.rb

@@ -2,7 +2,7 @@ module Cucumber
   module Core
     class Version
       def self.to_s
-        "1.1.3"
+        "1.2.0"
       end
     end
   end

data/spec/cucumber/core/ast/examples_table_spec.rb

@@ -4,9 +4,10 @@ module Cucumber::Core::Ast
   describe ExamplesTable do
     let(:location) { double(:to_s => 'file.feature:8') }
     let(:language) { double }
+    let(:comments) { double }
 
     describe ExamplesTable::Header do
-      let(:header) { ExamplesTable::Header.new(%w{foo bar baz}, location) }
+      let(:header) { ExamplesTable::Header.new(%w{foo bar baz}, location, comments) }
 
       describe 'location' do
         it 'knows the file and line number' do
@@ -14,9 +15,15 @@ module Cucumber::Core::Ast
         end
       end
 
+      describe 'comments' do
+        it "has comments" do
+          expect( header ).to respond_to(:comments)
+        end
+      end
+
       context 'building a row' do
         it 'includes the header values as keys' do
-          expect( header.build_row(%w{1 2 3}, 1, location, language) ).to eq ExamplesTable::Row.new({'foo' => '1', 'bar' => '2', 'baz' => '3'}, 1, location, language)
+          expect( header.build_row(%w{1 2 3}, 1, location, language, comments) ).to eq ExamplesTable::Row.new({'foo' => '1', 'bar' => '2', 'baz' => '3'}, 1, location, language, comments)
         end
       end
     end
@@ -24,21 +31,27 @@ module Cucumber::Core::Ast
 
       describe 'location' do
         it 'knows the file and line number' do
-          row = ExamplesTable::Row.new({}, 1, location, language)
+          row = ExamplesTable::Row.new({}, 1, location, language, comments)
           expect( row.file_colon_line ).to eq 'file.feature:8'
         end
       end
 
       describe 'language' do
         it "has a language" do
-          expect( ExamplesTable::Row.new({}, 1, location, language) ).to respond_to(:language)
+          expect( ExamplesTable::Row.new({}, 1, location, language, comments) ).to respond_to(:language)
+        end
+      end
+
+      describe 'comments' do
+        it "has comments" do
+          expect( ExamplesTable::Row.new({}, 1, location, language, comments) ).to respond_to(:comments)
         end
       end
 
       describe "expanding a string" do
         context "when an argument matches" do
           it "replaces the argument with the value from the row" do
-            row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language)
+            row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language, comments)
             text = 'this <arg> a test'
             expect( row.expand(text) ).to eq 'this replacement a test'
           end
@@ -46,7 +59,7 @@ module Cucumber::Core::Ast
 
         context "when the replacement value is nil" do
           it "uses an empty string for the replacement" do
-            row = ExamplesTable::Row.new({'color' => nil}, 1, location, language)
+            row = ExamplesTable::Row.new({'color' => nil}, 1, location, language, comments)
             text = 'a <color> cucumber'
             expect( row.expand(text) ).to eq 'a  cucumber'
           end
@@ -54,7 +67,7 @@ module Cucumber::Core::Ast
 
         context "when an argument does not match" do
           it "ignores the arguments that do not match" do
-            row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location, language)
+            row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location, language, comments)
             text = 'foo <x> bar <z>'
             expect( row.expand(text) ).to eq 'foo 1 bar <z>'
           end
@@ -63,7 +76,7 @@ module Cucumber::Core::Ast
 
       describe 'accesing the values' do
         it 'returns the actual row values' do
-          row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location, language)
+          row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location, language, comments)
           expect( row.values ).to eq ['1', '2']
         end
       end
@@ -72,16 +85,16 @@ module Cucumber::Core::Ast
         let(:data) { {} }
         let(:number) { double }
         let(:location) { double }
-        let(:original) { ExamplesTable::Row.new(data, number, location, language) }
+        let(:original) { ExamplesTable::Row.new(data, number, location, language, comments) }
 
         it 'is equal to another instance with the same data, number and location' do
-          expect( original ).to eq ExamplesTable::Row.new(data, number, location, language)
+          expect( original ).to eq ExamplesTable::Row.new(data, number, location, language, comments)
         end
 
         it 'is not equal to another instance with different data, number or location' do
-          expect( original ).not_to eq ExamplesTable::Row.new({'x' => 'y'}, number, location, language)
-          expect( original ).not_to eq ExamplesTable::Row.new(data, double, location, language)
-          expect( original ).not_to eq ExamplesTable::Row.new(data, number, double, double)
+          expect( original ).not_to eq ExamplesTable::Row.new({'x' => 'y'}, number, location, language, comments)
+          expect( original ).not_to eq ExamplesTable::Row.new(data, double, location, language, comments)
+          expect( original ).not_to eq ExamplesTable::Row.new(data, number, double, double, double)
         end
 
         it 'is not equal to another type of object' do

data/spec/cucumber/core/ast/outline_step_spec.rb

@@ -8,10 +8,11 @@ module Cucumber
   module Core
     module Ast
       describe OutlineStep do
-        let(:outline_step) { OutlineStep.new(node, language, location, keyword, name, multiline_arg) }
+        let(:outline_step) { OutlineStep.new(node, language, location, comments, keyword, name, multiline_arg) }
         let(:node) { double }
         let(:language) { double }
         let(:location) { double }
+        let(:comments)  { double }
         let(:keyword)  { double }
         let(:name)     { 'anything' }
         let(:multiline_arg) { EmptyMultilineArgument.new }
@@ -27,19 +28,25 @@ module Cucumber
           end
         end
 
+        describe 'comments' do
+          it "has comments" do
+            expect( outline_step ).to respond_to(:comments)
+          end
+        end
+
         describe "converting to a Step" do
           context "a single argument in the name" do
             let(:name) { 'a <color> cucumber' }
 
             it "replaces the argument" do
-              row = ExamplesTable::Row.new({'color' => 'green'}, 1, location, language)
+              row = ExamplesTable::Row.new({'color' => 'green'}, 1, location, language, comments)
               expect( outline_step.to_step(row).name ).to eq 'a green cucumber'
             end
 
           end
 
           context "when the step has a DataTable" do
-            let(:outline_step) { OutlineStep.new(node, language, location, keyword, name, table) }
+            let(:outline_step) { OutlineStep.new(node, language, location, comments, keyword, name, table) }
             let(:name)  { "anything" }
             let(:table) { DataTable.new([['x', 'y'],['a', 'a <arg>']], Location.new('foo.feature', 23)) }
 
@@ -49,7 +56,7 @@ module Cucumber
               expect( visitor ).to receive(:data_table) do |data_table|
                 expect( data_table.raw ).to eq [['x', 'y'], ['a', 'a replacement']]
               end
-              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language)
+              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language, comments)
               step = outline_step.to_step(row)
               step.describe_to(visitor)
             end
@@ -57,7 +64,7 @@ module Cucumber
 
           context "when the step has a DocString" do
             let(:location) { double }
-            let(:outline_step) { OutlineStep.new(node, language, location, keyword, name, doc_string) }
+            let(:outline_step) { OutlineStep.new(node, language, location, comments, keyword, name, doc_string) }
             let(:doc_string) { DocString.new('a <arg> that needs replacing', '', location) }
             let(:name) { 'anything' }
 
@@ -67,7 +74,7 @@ module Cucumber
               expect( visitor ).to receive(:doc_string) do |doc_string|
                 expect( doc_string.content ).to eq "a replacement that needs replacing"
               end
-              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language)
+              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language, comments)
               step = outline_step.to_step(row)
               step.describe_to(visitor)
             end

data/spec/cucumber/core/ast/step_spec.rb

@@ -6,9 +6,9 @@ module Cucumber
     module Ast
       describe Step do
         let(:step) do
-          node, language, location, keyword, name = *double
+          node, language, location, comments, keyword, name = *double
           multiline_arg = EmptyMultilineArgument.new
-          Step.new(node, language, location, keyword, name, multiline_arg)
+          Step.new(node, language, location, comments, keyword, name, multiline_arg)
         end
 
         describe "describing itself" do
@@ -27,7 +27,7 @@ module Cucumber
           end
 
           context "with a multiline argument" do
-            let(:step) { Step.new(double, double, double, double, double, multiline_arg) }
+            let(:step) { Step.new(double, double, double, double, double, double, multiline_arg) }
             let(:multiline_arg) { double }
 
             it "tells its multiline argument to describe itself" do
@@ -39,8 +39,14 @@ module Cucumber
 
         end
 
+        describe 'comments' do
+          it "has comments" do
+            expect( step ).to respond_to(:comments)
+          end
+        end
+
         describe "backtrace line" do
-          let(:step) { Step.new(double, double, "path/file.feature:10", "Given ", "this step passes", double) }
+          let(:step) { Step.new(double, double, "path/file.feature:10", double, "Given ", "this step passes", double) }
 
           it "knows how to form the backtrace line" do
             expect( step.backtrace_line ).to eq("path/file.feature:10:in `Given this step passes'")
@@ -52,9 +58,9 @@ module Cucumber
           let(:language) { ::Gherkin::I18n.get('en') }
 
           context "for keywords 'given', 'when' and 'then'" do
-            let(:given_step) { Step.new(double, language, double, "Given ", double, double) }
-            let(:when_step) { Step.new(double, language, double, "When ", double, double) }
-            let(:then_step) { Step.new(double, language, double, "Then ", double, double) }
+            let(:given_step) { Step.new(double, language, double, double, "Given ", double, double) }
+            let(:when_step) { Step.new(double, language, double, double, "When ", double, double) }
+            let(:then_step) { Step.new(double, language, double, double, "Then ", double, double) }
 
             it "returns the keyword itself" do
               expect( given_step.actual_keyword(nil) ).to eq("Given ")
@@ -64,9 +70,9 @@ module Cucumber
           end
 
           context "for keyword 'and', 'but', and '*'" do
-            let(:and_step) { Step.new(double, language, double, "And ", double, double) }
-            let(:but_step) { Step.new(double, language, double, "But ", double, double) }
-            let(:asterisk_step) { Step.new(double, language, double, "* ", double, double) }
+            let(:and_step) { Step.new(double, language, double, double, "And ", double, double) }
+            let(:but_step) { Step.new(double, language, double, double, "But ", double, double) }
+            let(:asterisk_step) { Step.new(double, language, double, double, "* ", double, double) }
 
             context "when the previous step keyword exist" do
               it "returns the previous step keyword" do
@@ -88,7 +94,7 @@ module Cucumber
 
           context "for i18n languages" do
             let(:language) { ::Gherkin::I18n.get('en-lol') }
-            let(:and_step) { Step.new(double, language, double, "AN ", double, double) }
+            let(:and_step) { Step.new(double, language, double, double, "AN ", double, double) }
 
             it "returns the keyword in the correct language" do
               expect( and_step.actual_keyword(nil) ).to eq("I CAN HAZ ")
@@ -101,8 +107,9 @@ module Cucumber
         let(:outline_step) { double }
         let(:step) do
           node, language, location, keyword, name = *double
+          comments = []
           multiline_arg = EmptyMultilineArgument.new
-          ExpandedOutlineStep.new(outline_step, node, language, location, keyword, name, multiline_arg)
+          ExpandedOutlineStep.new(outline_step, node, language, location, comments, keyword, name, multiline_arg)
         end
 
         describe "describing itself" do
@@ -121,7 +128,7 @@ module Cucumber
           end
 
           context "with a multiline argument" do
-            let(:step) { Step.new(double, double, double, double, double, multiline_arg) }
+            let(:step) { ExpandedOutlineStep.new(double, double, double, double, double, double, double, multiline_arg) }
             let(:multiline_arg) { double }
 
             it "tells its multiline argument to describe itself" do
@@ -133,6 +140,12 @@ module Cucumber
 
         end
 
+        describe 'comments' do
+          it "has comments" do
+            expect( step ).to respond_to(:comments)
+          end
+        end
+
         describe "matching location" do
           let(:location) { double }
 
@@ -144,8 +157,8 @@ module Cucumber
         end
 
         describe "backtrace line" do
-          let(:outline_step) { OutlineStep.new(double, double, "path/file.feature:5", "Given ", "this step <state>", double) }
-          let(:step) { ExpandedOutlineStep.new(outline_step, double, double, "path/file.feature:10", "Given ", "this step passes", double) }
+          let(:outline_step) { OutlineStep.new(double, double, "path/file.feature:5", double, "Given ", "this step <state>", double) }
+          let(:step) { ExpandedOutlineStep.new(outline_step, double, double, "path/file.feature:10", double, "Given ", "this step passes", double) }
 
           it "includes the outline step in the backtrace line" do
             expect( step.backtrace_line ).to eq("path/file.feature:10:in `Given this step passes'\n" +

data/spec/cucumber/core/test/action_spec.rb

@@ -13,6 +13,28 @@ module Cucumber
           end
         end
 
+        context "location" do
+
+          context "with location passed to the constructor" do
+          let(:location) { double }
+
+            it "returns the location passed to the constructor" do
+              action = Action.new(location) {}
+              expect( action.location ).to be location
+            end
+          end
+
+          context "without location passed to the constructor" do
+            let(:block) { proc {} }
+
+            it "returns the location of the block passed to the constructor" do
+              action = Action.new(&block)
+              expect( action.location ).to eq Ast::Location.new(*block.source_location)
+            end
+          end
+
+        end
+
         context "executing" do
           it "executes the block passed to the constructor" do
             executed = false
@@ -105,9 +127,16 @@ module Cucumber
       end
 
       describe UndefinedAction do
-        let(:action) { UndefinedAction.new }
+        let(:location) { double }
+        let(:action) { UndefinedAction.new(location) }
         let(:test_step) { double }
 
+        context "location" do
+          it "returns the location passed to the constructor" do
+            expect( action.location ).to be location
+          end
+        end
+
         context "executing" do
           it "returns an undefined result" do
             expect( action.execute ).to be_undefined

data/spec/cucumber/core/test/result_spec.rb

@@ -30,11 +30,25 @@ module Cucumber::Core::Test
         expect { Result::Passed.new }.to raise_error(ArgumentError)
       end
 
-      it { expect( result ).to     be_passed    }
-      it { expect( result ).not_to be_failed    }
-      it { expect( result ).not_to be_undefined }
-      it { expect( result ).not_to be_unknown   }
-      it { expect( result ).not_to be_skipped   }
+      it "does nothing when appending the backtrace" do
+        expect( result.with_appended_backtrace(double) ).to equal result
+      end
+
+      it "does nothing when filtering the backtrace" do
+        expect( result.with_filtered_backtrace(double) ).to equal result
+      end
+
+      specify { expect( result.to_sym ).to eq :passed }
+
+      specify { expect( result ).to     be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok?(false) ).to be_truthy }
+      specify { expect( result.ok?(true) ).to be_truthy }
     end
 
     describe Result::Failed do
@@ -58,11 +72,42 @@ module Cucumber::Core::Test
         expect { Result::Failed.new(duration) }.to raise_error(ArgumentError)
       end
 
-      it { expect( result ).not_to be_passed    }
-      it { expect( result ).to     be_failed    }
-      it { expect( result ).not_to be_undefined }
-      it { expect( result ).not_to be_unknown   }
-      it { expect( result ).not_to be_skipped   }
+      it "does nothing if step has no backtrace line" do
+        result.exception.set_backtrace("exception backtrace")
+        step = "does not respond_to?(:backtrace_line)"
+
+        expect( result.with_appended_backtrace(step).exception.backtrace ).to eq(["exception backtrace"])
+      end
+
+      it "appends the backtrace line of the step" do
+        result.exception.set_backtrace("exception backtrace")
+        step = double
+        expect( step ).to receive(:backtrace_line).and_return("step_line")
+
+        expect( result.with_appended_backtrace(step).exception.backtrace ).to eq(["exception backtrace", "step_line"])
+      end
+
+      it "apply filters to the exception" do
+        filter_class = double
+        filter = double
+        filtered_exception = double
+        expect( filter_class ).to receive(:new).with(result.exception).and_return(filter)
+        expect( filter ).to receive(:exception).and_return(filtered_exception)
+
+        expect( result.with_filtered_backtrace(filter_class).exception ).to equal filtered_exception
+      end
+
+      specify { expect( result.to_sym ).to eq :failed }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).to     be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+
+      specify { expect( result ).to_not be_ok }
+      specify { expect( result.ok?(false) ).to be_falsey }
+      specify { expect( result.ok?(true) ).to be_falsey }
     end
 
     describe Result::Unknown do
@@ -73,11 +118,61 @@ module Cucumber::Core::Test
         result.describe_to(visitor, args)
       end
 
-      it { expect( result ).not_to be_passed    }
-      it { expect( result ).not_to be_failed    }
-      it { expect( result ).not_to be_undefined }
-      it { expect( result ).to     be_unknown   }
-      it { expect( result ).not_to be_skipped   }
+      specify { expect( result.to_sym ).to eq :unknown }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).to     be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+    end
+
+    describe Result::Raisable do
+      context "with or without backtrace" do
+        subject(:result) { Result::Raisable.new }
+
+        it "does nothing if step has no backtrace line" do
+          step = "does not respond_to?(:backtrace_line)"
+
+          expect( result.with_appended_backtrace(step).backtrace ).to eq(nil)
+        end
+      end
+
+      context "without backtrace" do
+        subject(:result) { Result::Raisable.new }
+
+        it "set the backtrace to the backtrace line of the step" do
+          step = double
+          expect( step ).to receive(:backtrace_line).and_return("step_line")
+
+          expect( result.with_appended_backtrace(step).backtrace ).to eq(["step_line"])
+        end
+
+        it "does nothing when filtering the backtrace" do
+          expect( result.with_filtered_backtrace(double) ).to equal result
+        end
+      end
+
+      context "with backtrace" do
+        subject(:result) { Result::Raisable.new("message", 0, "backtrace") }
+
+        it "appends the backtrace line of the step" do
+          step = double
+          expect( step ).to receive(:backtrace_line).and_return("step_line")
+
+          expect( result.with_appended_backtrace(step).backtrace ).to eq(["backtrace", "step_line"])
+        end
+
+        it "apply filters to the backtrace" do
+          filter_class = double
+          filter = double
+          filtered_result = double
+          expect( filter_class ).to receive(:new).with(result.exception).and_return(filter)
+          expect( filter ).to receive(:exception).and_return(filtered_result)
+
+          expect( result.with_filtered_backtrace(filter_class) ).to equal filtered_result
+        end
+      end
     end
 
     describe Result::Undefined do
@@ -89,11 +184,17 @@ module Cucumber::Core::Test
         result.describe_to(visitor, args)
       end
 
-      it { expect( result ).not_to be_passed    }
-      it { expect( result ).not_to be_failed    }
-      it { expect( result ).to     be_undefined }
-      it { expect( result ).not_to be_unknown   }
-      it { expect( result ).not_to be_skipped   }
+      specify { expect( result.to_sym ).to eq :undefined }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).to     be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok?(false) ).to be_truthy }
+      specify { expect( result.ok?(true) ).to be_falsey }
     end
 
     describe Result::Skipped do
@@ -105,11 +206,40 @@ module Cucumber::Core::Test
         result.describe_to(visitor, args)
       end
 
-      it { expect( result ).not_to be_passed    }
-      it { expect( result ).not_to be_failed    }
-      it { expect( result ).not_to be_undefined }
-      it { expect( result ).not_to be_unknown   }
-      it { expect( result ).to     be_skipped   }
+      specify { expect( result.to_sym ).to eq :skipped }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).to     be_skipped   }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok?(false) ).to be_truthy }
+      specify { expect( result.ok?(true) ).to be_truthy }
+    end
+
+    describe Result::Pending do
+      subject(:result) { Result::Pending.new }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:pending).with(result, args)
+        expect( visitor ).to receive(:duration).with(an_unknown_duration, args)
+        result.describe_to(visitor, args)
+      end
+
+      specify { expect( result.to_sym ).to eq :pending }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+      specify { expect( result ).to     be_pending   }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok?(false) ).to be_truthy }
+      specify { expect( result.ok?(true) ).to be_falsey }
     end
 
     describe Result::Summary do