cucumber-core 0.2.0 → 1.0.0.beta.1

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

@@ -0,0 +1,30 @@
+require 'cucumber/core/test/hooks'
+module Cucumber::Core::Test::Hooks
+  shared_examples_for 'a source node' do
+    it "responds to name" do
+      expect( subject.name ).to be_a(String)
+    end
+
+    it "responds to location" do
+      expect( subject.location ).to eq(location)
+    end
+
+    it "responds to match_locations?" do
+      expect( subject.match_locations? [location] ).to be_truthy
+      expect( subject.match_locations? [] ).to be_falsey
+    end
+  end
+
+  require 'cucumber/core/ast/location'
+  describe BeforeHook do
+    subject { BeforeHook.new(location) }
+    let(:location) { Cucumber::Core::Ast::Location.new('hooks.rb', 1) }
+    it_behaves_like 'a source node'
+  end
+
+  describe AfterHook do
+    subject { AfterHook.new(location) }
+    let(:location) { Cucumber::Core::Ast::Location.new('hooks.rb', 1) }
+    it_behaves_like 'a source node'
+  end
+end

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

@@ -1,6 +1,7 @@
 require 'cucumber/core/test/mapper'
 require 'cucumber/core/test/case'
 require 'cucumber/core/test/step'
+require 'cucumber/core/ast'
 
 module Cucumber
   module Core
@@ -8,6 +9,9 @@ module Cucumber
       describe Mapper do
 
         ExampleMappings = Struct.new(:app) do
+          def test_case(test_case, mapper)
+          end
+
           def test_step(test_step, mapper)
             mapper.map { app.do_something } if test_step.name == 'mapped'
           end
@@ -15,7 +19,7 @@ module Cucumber
 
         let(:mapper)   { Mapper.new(mappings, receiver) }
         let(:receiver) { double('receiver') }
-        before         { receiver.stub(:test_case).and_yield }
+        before         { allow(receiver).to receive(:test_case).and_yield(receiver) }
         let(:mappings) { ExampleMappings.new(app) }
         let(:app)      { double('app') }
 
@@ -61,7 +65,117 @@ module Cucumber
             test_case.describe_to mapper
           end
         end
+
+        context "mapping hooks" do
+          let(:test_case)  { Case.new([test_step], source) }
+          let(:test_step)  { Step.new([Ast::Step.new(:language, :location, :keyword, :name, :multiline_arg)]) }
+          let(:source)     { [feature, scenario] }
+          let(:feature)    { double('feature') }
+          let(:scenario)   { double('scenario', location: 'test') }
+
+          it "prepends before hooks to the test case" do
+            allow( mappings ).to receive(:test_case) do |test_case, mapper|
+              mapper.before {}
+            end
+            expect( receiver ).to receive(:test_case) do |test_case|
+              expect( test_case.step_count ).to eq 2
+            end
+            test_case.describe_to mapper
+          end
+
+          it "appends after hooks to the test case" do
+            allow( mappings ).to receive(:test_case) do |test_case, mapper|
+              mapper.after {}
+            end
+            expect( receiver ).to receive(:test_case) do |test_case|
+              expect( test_case.step_count ).to eq 2
+            end
+            test_case.describe_to mapper
+          end
+
+          it "adds hooks in the right order" do
+            log = double
+            allow(mappings).to receive(:test_case) do |test_case, mapper|
+              mapper.before { log.before }
+              mapper.after { log.after }
+            end
+            mapped_step = test_step.with_mapping { log.step }
+            test_case = Case.new([mapped_step], source)
+
+            expect( log ).to receive(:before).ordered
+            expect( log ).to receive(:step).ordered
+            expect( log ).to receive(:after).ordered
+
+            allow(receiver).to receive(:test_case).and_yield(receiver)
+            allow(receiver).to receive(:test_step) do |test_step|
+              test_step.execute
+            end
+
+            test_case.describe_to mapper
+          end
+
+          it "sets the source to include the before hook, scenario and feature" do
+            test_case = Case.new([], source)
+            allow(mappings).to receive(:test_case) do |test_case_to_be_mapped, mapper|
+              mapper.before {}
+            end
+            allow(receiver).to receive(:test_case).and_yield(receiver)
+            allow(receiver).to receive(:test_step) do |test_step|
+              args = double('args')
+              visitor = double('visitor')
+              expect( feature ).to receive(:describe_to)
+              expect( scenario ).to receive(:describe_to)
+              expect( visitor ).to receive(:before_hook) do |hook, hook_args|
+                expect( args ).to eq(hook_args)
+                expect( hook.location.to_s ).to eq("#{__FILE__}:120")
+              end
+              test_step.describe_source_to(visitor, args)
+            end
+            test_case.describe_to mapper
+          end
+
+          it "sets the source to include the after hook" do
+            test_case = Case.new([], source)
+            allow(mappings).to receive(:test_case) do |test_case_to_be_mapped, mapper|
+              mapper.after {}
+            end
+            allow(receiver).to receive(:test_case).and_yield(receiver)
+            allow(receiver).to receive(:test_step) do |test_step|
+              args = double('args')
+              visitor = double('visitor')
+              expect( feature ).to receive(:describe_to)
+              expect( scenario ).to receive(:describe_to)
+              expect( visitor ).to receive(:after_hook) do |hook, hook_args|
+                expect( args ).to eq(hook_args)
+                expect( hook.location.to_s ).to eq("#{__FILE__}:140")
+              end
+              test_step.describe_source_to(visitor, args)
+            end
+            test_case.describe_to mapper
+          end
+
+          it "appends after_step hooks to the test step" do
+            allow(mappings).to receive(:test_step) do |test_step, mapper|
+              mapper.after {}
+            end
+            args = double('args')
+            visitor = double('visitor')
+            allow(receiver).to receive(:test_case).and_yield(receiver)
+            allow(receiver).to receive(:test_step) do |test_step|
+              test_step.describe_source_to(visitor, args)
+            end
+            expect( visitor ).to receive(:step).ordered
+            expect( visitor ).to receive(:after_step_hook) do |hook, hook_args|
+              expect( args ).to eq(hook_args)
+              expect( hook.location.to_s ).to eq("#{__FILE__}:159")
+            end.once.ordered
+            expect( visitor ).to receive(:step).ordered
+            test_case.describe_to mapper
+          end
+
+        end
       end
+
     end
   end
 end

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

@@ -17,7 +17,7 @@ module Cucumber
             executed = false
             mapping = Mapping.new { executed = true }
             mapping.execute
-            expect( executed ).to be_true
+            expect( executed ).to be_truthy
           end
 
           it "returns a passed result if the block doesn't fail" do
@@ -33,7 +33,7 @@ module Cucumber
             expect( result.exception ).to eq exception
           end
 
-          it "returns a pending result if a pending error is raised" do
+          it "returns a pending result if a Result::Pending error is raised" do
             exception = Result::Pending.new("TODO")
             mapping = Mapping.new { raise exception }
             result = mapping.execute
@@ -41,12 +41,28 @@ module Cucumber
             expect( result.message ).to eq "TODO"
           end
 
+          it "returns a skipped result if a Result::Skipped error is raised" do
+            exception = Result::Skipped.new("Not working right now")
+            mapping = Mapping.new { raise exception }
+            result = mapping.execute
+            expect( result ).to be_skipped
+            expect( result.message ).to eq "Not working right now"
+          end
+
+          it "returns an undefined result if a Result::Undefined error is raised" do
+            exception = Result::Undefined.new("new step")
+            mapping = Mapping.new { raise exception }
+            result = mapping.execute
+            expect( result ).to be_undefined
+            expect( result.message ).to eq "new step"
+          end
+
           context "recording the duration" do
             before do
               time = double
-              Time.stub(now: time)
-              time.stub(:nsec).and_return(946752000, 946752001)
-              time.stub(:to_i).and_return(1377009235, 1377009235)
+              allow( Time ).to receive(:now) { time }
+              allow( time ).to receive(:nsec).and_return(946752000, 946752001)
+              allow( time ).to receive(:to_i).and_return(1377009235, 1377009235)
             end
 
             it "records the nanoseconds duration of the execution on the result" do
@@ -69,7 +85,7 @@ module Cucumber
             executed = false
             mapping = Mapping.new { executed = true }
             mapping.skip
-            expect( executed ).to be_false
+            expect( executed ).to be_falsey
           end
 
           it "returns a skipped result" do

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

@@ -72,10 +72,6 @@ module Cucumber::Core::Test
         result.describe_to(visitor, args)
       end
 
-      it "has no duration" do
-        expect { result.duration }.to raise_error NoMethodError
-      end
-
       it { expect( result ).not_to be_passed    }
       it { expect( result ).not_to be_failed    }
       it { expect( result ).not_to be_undefined }
@@ -106,10 +102,6 @@ module Cucumber::Core::Test
         result.describe_to(visitor, args)
       end
 
-      it "has no duration" do
-        expect { result.duration }.to raise_error NoMethodError
-      end
-
       it { expect( result ).not_to be_passed    }
       it { expect( result ).not_to be_failed    }
       it { expect( result ).not_to be_undefined }

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

@@ -9,18 +9,23 @@ module Cucumber::Core::Test
     let(:source)    { double }
     let(:runner)    { Runner.new(report) }
     let(:report)    { double.as_null_object }
-    let(:passing)   { Step.new([double]).map {} }
-    let(:failing)   { Step.new([double]).map { raise exception } }
-    let(:pending)   { Step.new([double]).map { raise Result::Pending.new("TODO") } }
+    let(:passing)   { Step.new([double]).with_mapping {} }
+    let(:failing)   { Step.new([double]).with_mapping { raise exception } }
+    let(:pending)   { Step.new([double]).with_mapping { raise Result::Pending.new("TODO") } }
+    let(:skipping)  { Step.new([double]).with_mapping { raise Result::Skipped.new } }
     let(:undefined) { Step.new([double]) }
     let(:exception) { StandardError.new('test error') }
 
+    before do
+      allow(report).to receive(:before_test_case)
+    end
+
     context "reporting the duration of a test case" do
       before do
         time = double
-        Time.stub(now: time)
-        time.stub(:nsec).and_return(946752000, 946752001)
-        time.stub(:to_i).and_return(1377009235, 1377009235)
+        allow(Time).to receive(:now).and_return(time)
+        allow(time).to receive(:nsec).and_return(946752000, 946752001)
+        allow(time).to receive(:to_i).and_return(1377009235, 1377009235)
       end
 
       context "for a passing test case" do
@@ -49,6 +54,7 @@ module Cucumber::Core::Test
     context "reporting the exception that failed a test case" do
       let(:test_steps) { [failing] }
       it "sets the exception on the result" do
+        allow(report).to receive(:before_test_case)
         expect( report ).to receive(:after_test_case) do |reported_test_case, result|
           expect( result.exception ).to eq exception
         end
@@ -108,6 +114,17 @@ module Cucumber::Core::Test
           end
         end
 
+        context "a skipping step" do
+          let(:test_steps) { [skipping] }
+
+          it "reports a skipped test case" do
+            expect( report ).to receive(:after_test_case) do |test_case, result|
+              expect( result ).to be_skipped
+            end
+            test_case.describe_to runner
+          end
+        end
+
         context 'that fail' do
           let(:test_steps) { [ failing ] }
 
@@ -122,6 +139,14 @@ module Cucumber::Core::Test
         context 'where the first step fails' do
           let(:test_steps) { [ failing, passing ] }
 
+          it 'executes the after hook at the end regardless of the failure' do
+            expect( report ).to receive(:after_test_case) do |test_case, result|
+              expect( result ).to be_failed
+              expect( result.exception ).to eq exception
+            end
+            test_case.describe_to runner
+          end
+
           it 'reports the first step as failed' do
             expect( report ).to receive(:after_test_step).with(failing, anything) do |test_step, result|
               expect( result ).to be_failed
@@ -171,95 +196,4 @@ module Cucumber::Core::Test
     end
 
   end
-
-  describe 'with the dry run strategy'  do
-
-    let(:report) { double(:report).as_null_object }
-    let(:source) { double(:source) }
-    let(:runner) { Runner.new(report, :run_mode => :dry_run) }
-    let(:passing) { Step.new([double]).map {} }
-    let(:undefined) { Step.new([double]) }
-    let(:test_case) { Case.new(test_steps, source) }
-
-    context 'with a passing step' do
-      let(:test_steps) { [passing] }
-
-      it 'reports the test case as skipped' do
-        report.should_receive(:after_test_case) do |test_case, result|
-          result.should be_skipped
-        end
-        test_case.describe_to runner
-      end
-
-      it 'reports the test step has been skipped' do
-        report.should_receive(:after_test_step) do |test_step, result|
-          result.should be_skipped
-        end
-        test_case.describe_to runner
-      end
-    end
-
-    context 'with a undefined step' do
-      let(:test_steps) { [undefined] }
-
-      it 'reports the test case as undefined' do
-        report.should_receive(:after_test_case) do |test_case, result|
-          result.should be_undefined
-        end
-        test_case.describe_to runner
-      end
-
-
-      it 'reports the test step as undefined' do
-        report.should_receive(:after_test_step) do |test_step, result|
-          result.should be_undefined
-        end
-        test_case.describe_to runner
-      end
-    end
-
-    context 'with passing and undefined steps' do
-      let(:test_steps) { [passing, undefined] }
-
-      it 'reports the test case as undefined' do
-        report.should_receive(:after_test_case) do |test_case, result|
-          result.should be_undefined
-        end
-        test_case.describe_to runner
-      end
-
-      it 'reports the passing step as skipped' do
-        report.should_receive(:after_test_step).with(passing, anything) do |test_case, result|
-          result.should be_skipped
-        end
-        test_case.describe_to runner
-      end
-
-      it 'reports the undefined step as undefined' do
-        report.should_receive(:after_test_step).with(undefined, anything) do |test_case, result|
-          result.should be_undefined
-        end
-        test_case.describe_to runner
-      end
-    end
-
-    context 'with multiple test cases' do
-      context 'when the first test case is undefined' do
-        let(:first_test_case) { Case.new([undefined], source) }
-        let(:last_test_case)  { Case.new([passing], source) }
-        let(:test_cases)      { [first_test_case, last_test_case] }
-
-        it 'reports the results correctly for the following test case' do
-          report.
-            should_receive(:after_test_case).
-            with(last_test_case, anything) do |reported_test_case, result|
-            result.should be_skipped
-            end
-
-          test_cases.each { |c| c.describe_to runner }
-        end
-      end
-    end
-  end
-
 end

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

@@ -13,45 +13,53 @@ module Cucumber::Core::Test
       end
 
       it "describes its source to a visitor" do
-        feature, scenario, step = double, double, double
+        feature, scenario, step_or_hook = double, double, double
         visitor = double
         args = double
-        expect( feature  ).to receive(:describe_to).with(visitor, args)
-        expect( scenario ).to receive(:describe_to).with(visitor, args)
-        expect( step     ).to receive(:describe_to).with(visitor, args)
-        test_step = Step.new([feature, scenario, step])
+        expect( feature      ).to receive(:describe_to).with(visitor, args)
+        expect( scenario     ).to receive(:describe_to).with(visitor, args)
+        expect( step_or_hook ).to receive(:describe_to).with(visitor, args)
+        test_step = Step.new([feature, scenario, step_or_hook])
         test_step.describe_source_to(visitor, args)
       end
     end
 
-    describe "executing a step" do
+    describe "executing" do
       let(:ast_step) { double }
 
-      context "when a passing mapping exists for the step" do
+      context "when a passing mapping exists" do
         it "returns a passing result" do
-          test_step = Step.new([ast_step]).map {}
+          test_step = Step.new([ast_step]).with_mapping {}
           expect( test_step.execute ).to be_passed
         end
       end
 
-      context "when a failing mapping exists for the step" do
+      context "when a failing mapping exists" do
         let(:exception) { StandardError.new('oops') }
 
         it "returns a failing result" do
-          test_step = Step.new([ast_step]).map { raise exception }
+          test_step = Step.new([ast_step]).with_mapping { raise exception }
           result = test_step.execute
           expect( result           ).to be_failed
           expect( result.exception ).to eq exception
         end
       end
+
+      context "with no mapping" do
+        it "returns an Undefined result" do
+          test_step = Step.new([ast_step])
+          result = test_step.execute
+          expect( result           ).to be_undefined
+        end
+      end
     end
 
-    it "exposes the name and multiline_arg of the ast step as attributes" do
-      name, multiline_arg = double, double
-      ast_step = double(name: name, multiline_arg: multiline_arg)
-      test_step = Step.new([ast_step])
-      expect( test_step.name          ).to eq name
-      expect( test_step.multiline_arg ).to eq multiline_arg
+    it "exposes the name and location of the AST step or hook as attributes" do
+      name, location = double, double
+      step_or_hook = double(name: name, location: location)
+      test_step = Step.new([step_or_hook])
+      expect( test_step.name     ).to eq name
+      expect( test_step.location ).to eq location
     end
 
   end