cucumber-core 1.5.0 → 2.0.0

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/core/test/action'
 require 'cucumber/core/test/duration_matcher'
 

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # -*- coding: utf-8 -*-
 require 'cucumber/core'
 require 'cucumber/core/gherkin/writer'
@@ -13,8 +14,8 @@ module Cucumber
         include Core::Gherkin::Writer
 
         let(:test_case) { Test::Case.new(test_steps, [feature, scenario]) }
-        let(:feature) { double }
-        let(:scenario) { double }
+        let(:feature) { double(location: "features/test.feature:1") }
+        let(:scenario) { double(location: "features/test.feature:2") }
         let(:test_steps) { [double, double] }
 
         context 'describing itself' do
@@ -232,6 +233,29 @@ module Cucumber
           end
         end
 
+        describe "equality" do
+          it "is equal to another test case at the same location" do
+            gherkin = gherkin('features/foo.feature') do
+              feature do
+                scenario do
+                  step
+                end
+              end
+            end
+            test_case_instances = []
+            receiver = double.as_null_object
+            allow(receiver).to receive(:test_case) do |test_case|
+              test_case_instances << test_case
+            end
+            2.times { compile([gherkin], receiver) }
+            expect(test_case_instances.length).to eq 2
+            expect(test_case_instances.uniq.length).to eq 1
+            expect(test_case_instances[0]).to be_eql test_case_instances[1]
+            expect(test_case_instances[0]).to eq test_case_instances[1]
+            expect(test_case_instances[0]).not_to equal test_case_instances[1]
+          end
+        end
+
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require 'cucumber/core/test/result'
 require 'rspec/expectations'
 
@@ -12,7 +13,7 @@ module Cucumber::Core::Test
 
   RSpec::Matchers.define :an_unknown_duration do
     match do |actual|
-      actual.tap { raise "#tap block was executed, not an UnknownDuration" } 
+      actual.tap { raise "#tap block was executed, not an UnknownDuration" }
       expect(actual).to respond_to(:nanoseconds)
     end
   end

data/spec/cucumber/core/test/filters/locations_filter_spec.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 require 'cucumber/core/gherkin/writer'
 require 'cucumber/core'
 require 'cucumber/core/test/filters/locations_filter'
@@ -364,6 +365,7 @@ module Cucumber::Core
       end
 
       max_duration_ms = 10000
+      max_duration_ms = max_duration_ms * 2.5 if defined?(JRUBY_VERSION)
       it "filters #{num_features * num_scenarios_per_feature} test cases within #{max_duration_ms}ms" do
         filter = Test::LocationsFilter.new(locations)
         Timeout.timeout(max_duration_ms / 1000.0) do

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

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require 'cucumber/core/test/result'
 require 'cucumber/core/test/duration_matcher'
 
@@ -118,6 +119,10 @@ module Cucumber::Core::Test
         result.describe_to(visitor, args)
       end
 
+      it "defines a with_filtered_backtrace method" do
+        expect(result.with_filtered_backtrace(double("filter"))).to eql result
+      end
+
       specify { expect( result.to_sym ).to eq :unknown }
 
       specify { expect( result ).not_to be_passed    }

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/core/test/runner'
 require 'cucumber/core/test/case'
 require 'cucumber/core/test/step'
@@ -8,8 +9,8 @@ module Cucumber::Core::Test
 
     let(:test_case) { Case.new(test_steps, source) }
     let(:source)    { [double('ast node', location: double)] }
-    let(:runner)    { Runner.new(report) }
-    let(:report)    { double.as_null_object }
+    let(:runner)    { Runner.new(event_bus) }
+    let(:event_bus)    { double.as_null_object }
     let(:passing)   { Step.new([source]).with_action {} }
     let(:failing)   { Step.new([source]).with_action { raise exception } }
     let(:pending)   { Step.new([source]).with_action { raise Result::Pending.new("TODO") } }
@@ -18,7 +19,7 @@ module Cucumber::Core::Test
     let(:exception) { StandardError.new('test error') }
 
     before do
-      allow(report).to receive(:before_test_case)
+      allow(event_bus).to receive(:test_case_starting)
       allow(source).to receive(:location)
     end
 
@@ -31,7 +32,7 @@ module Cucumber::Core::Test
         let(:test_steps) { [passing] }
 
         it "records the nanoseconds duration of the execution on the result" do
-          expect( report ).to receive(:after_test_case) do |reported_test_case, result|
+          expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
             expect( result.duration ).to be_duration 1
           end
           test_case.describe_to runner
@@ -42,8 +43,8 @@ module Cucumber::Core::Test
         let(:test_steps) { [failing] }
 
         it "records the duration" do
-          expect( report ).to receive(:after_test_case) do |reported_test_case, result|
-            expect( result.duration ).to be_duration 1
+          expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
+            expect(result.duration).to be_duration 1
           end
           test_case.describe_to runner
         end
@@ -53,8 +54,8 @@ 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|
+        allow(event_bus).to receive(:before_test_case)
+        expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
           expect( result.exception ).to eq exception
         end
         test_case.describe_to runner
@@ -65,13 +66,13 @@ module Cucumber::Core::Test
       context "without steps" do
         let(:test_steps) { [] }
 
-        it "calls the report before running the case" do
-          expect( report ).to receive(:before_test_case).with(test_case)
+        it "emits a test_case_starting event before running the test case" do
+          expect(event_bus).to receive(:test_case_starting).with(test_case)
           test_case.describe_to runner
         end
 
-        it "calls the report after running the case" do
-          expect( report ).to receive(:after_test_case) do |reported_test_case, result|
+        it "emits the test_case_finished event after running the the test case" do
+          expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
             expect( reported_test_case ).to eq test_case
             expect( result ).to be_unknown
           end
@@ -83,8 +84,8 @@ module Cucumber::Core::Test
         context 'that all pass' do
           let(:test_steps) { [ passing, passing ]  }
 
-          it 'reports a passing test case' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+          it 'emits the test_case_finished event with a passing result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result ).to be_passed
             end
             test_case.describe_to runner
@@ -94,8 +95,8 @@ module Cucumber::Core::Test
         context 'an undefined step' do
           let(:test_steps) { [ undefined ]  }
 
-          it 'reports an undefined test case' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+          it 'emits the test_case_finished event with an undefined result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result ).to be_undefined
             end
             allow( undefined.source.last ).to receive(:name)
@@ -103,7 +104,7 @@ module Cucumber::Core::Test
           end
 
           it 'sets the message on the result' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result.message ).to eq("Undefined step: \"step name\"")
             end
             expect( undefined.source.last ).to receive(:name).and_return("step name")
@@ -111,7 +112,7 @@ module Cucumber::Core::Test
           end
 
           it 'appends the backtrace of the result' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result.backtrace ).to eq(["step line"])
             end
             expect( undefined.source.last ).to receive(:backtrace_line).and_return("step line")
@@ -123,15 +124,15 @@ module Cucumber::Core::Test
         context 'a pending step' do
           let(:test_steps) { [ pending ] }
 
-          it 'reports a pending test case' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+          it 'emits the test_case_finished event with a pending result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result ).to be_pending
             end
             test_case.describe_to runner
           end
 
           it 'appends the backtrace of the result' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result.backtrace.last ).to eq("step line")
             end
             expect( pending.source.last ).to receive(:backtrace_line).and_return("step line")
@@ -142,15 +143,15 @@ module Cucumber::Core::Test
         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|
+          it "emits the test_case_finished event with a skipped result" do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result ).to be_skipped
             end
             test_case.describe_to runner
           end
 
           it 'appends the backtrace of the result' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result.backtrace.last ).to eq("step line")
             end
             expect( skipping.source.last ).to receive(:backtrace_line).and_return("step line")
@@ -161,15 +162,15 @@ module Cucumber::Core::Test
         context 'that fail' do
           let(:test_steps) { [ failing ] }
 
-          it 'reports a failing test case' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+          it 'emits the test_case_finished event with a failing result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result ).to be_failed
             end
             test_case.describe_to runner
           end
 
           it 'appends the backtrace of the exception of the result' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result.exception.backtrace.last ).to eq("step line")
             end
             expect( failing.source.last ).to receive(:backtrace_line).and_return("step line")
@@ -180,30 +181,22 @@ 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|
+          it 'emits the test_step_finished event with a failed result' do
+            expect(event_bus).to receive(:test_step_finished).with(failing, anything) do |test_step, result|
               expect( result ).to be_failed
             end
             test_case.describe_to runner
           end
 
-          it 'reports the second step as skipped' do
-            expect( report ).to receive(:after_test_step).with(passing, anything) do |test_step, result|
+          it 'emits a test_step_finished event with a skipped result' do
+            expect(event_bus).to receive(:test_step_finished).with(passing, anything) do |test_step, result|
               expect( result ).to be_skipped
             end
             test_case.describe_to runner
           end
 
-          it 'reports the test case as failed' do
-            expect( report ).to receive(:after_test_case) do |test_case, result|
+          it 'emits a test_case_finished event with a failed result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
               expect( result ).to be_failed
               expect( result.exception ).to eq exception
             end
@@ -227,9 +220,10 @@ module Cucumber::Core::Test
         let(:test_cases)      { [first_test_case, last_test_case] }
 
         it 'reports the results correctly for the following test case' do
-          expect( report ).to receive(:after_test_case).with(last_test_case, anything) do |reported_test_case, result|
-            expect( result ).to be_passed
-          end
+          expect(event_bus).to receive(:test_case_finished) { |reported_test_case, result|
+            expect(result).to be_failed if reported_test_case.equal?(first_test_case)
+            expect(result).to be_passed if reported_test_case.equal?(last_test_case)
+          }.twice
 
           test_cases.each { |c| c.describe_to runner }
         end
@@ -256,7 +250,7 @@ module Cucumber::Core::Test
         around_hook = AroundHook.new { |block| block.call }
         passing_step = Step.new([source]).with_action {}
         test_case = Case.new([passing_step], source, [around_hook])
-        expect(report).to receive(:after_test_case).with(test_case, anything) do |reported_test_case, result|
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
           expect(result).to be_passed
         end
         test_case.describe_to runner
@@ -266,7 +260,7 @@ module Cucumber::Core::Test
         around_hook = AroundHook.new { |block| raise exception }
         passing_step = Step.new([source]).with_action {}
         test_case = Case.new([passing_step], source, [around_hook])
-        expect(report).to receive(:after_test_case).with(test_case, anything) do |reported_test_case, result|
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
           expect(result).to be_failed
           expect(result.exception).to eq exception
         end
@@ -277,7 +271,7 @@ module Cucumber::Core::Test
         around_hook = AroundHook.new { |block| block.call; raise exception }
         passing_step = Step.new([source]).with_action {}
         test_case = Case.new([passing_step], source, [around_hook])
-        expect(report).to receive(:after_test_case).with(test_case, anything) do |reported_test_case, result|
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
           expect(result).to be_failed
           expect(result.exception).to eq exception
         end
@@ -288,7 +282,7 @@ module Cucumber::Core::Test
         around_hook = AroundHook.new { |block| block.call }
         failing_step = Step.new([source]).with_action { raise exception }
         test_case = Case.new([failing_step], source, [around_hook])
-        expect(report).to receive(:after_test_case).with(test_case, anything) do |reported_test_case, result|
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
           expect(result).to be_failed
           expect(result.exception).to eq exception
         end
@@ -300,11 +294,11 @@ module Cucumber::Core::Test
         passing_step = Step.new([source]).with_action {}
         test_case = Case.new([], source, [around_hook])
         allow(runner).to receive(:running_test_step).and_return(passing_step)
-        expect(report).to receive(:after_test_step).with(passing_step, anything) do |reported_test_case, result|
+        expect(event_bus).to receive(:test_step_finished).with(passing_step, anything) do |reported_test_case, result|
           expect(result).to be_failed
           expect(result.exception).to eq exception
         end
-        expect(report).to receive(:after_test_case).with(test_case, anything) do |reported_test_case, result|
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
           expect(result).to be_failed
           expect(result.exception).to eq exception
         end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/core/test/step'
 
 module Cucumber::Core::Test

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/core/test/timer'
 require 'cucumber/core/test/duration_matcher'
 

data/spec/cucumber/core_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'report_api_spy'
 require 'cucumber/core'
 require 'cucumber/core/filter'
@@ -200,6 +201,61 @@ module Cucumber
     end
 
     describe "executing a test suite" do
+
+      it "fires events" do
+        gherkin = gherkin do
+          feature 'Feature name' do
+            scenario 'The one that passes' do
+              step 'passing'
+            end
+
+            scenario 'The one that fails' do
+              step 'passing'
+              step 'failing'
+              step 'passing'
+              step 'undefined'
+            end
+          end
+        end
+
+        observed_events = []
+        execute [gherkin], [Core::Test::Filters::ActivateStepsForSelfTest.new] do |event_bus|
+          event_bus.on(:test_case_starting) do |event|
+            test_case = event.test_case
+            observed_events << [:test_case_starting, test_case.name]
+          end
+          event_bus.on(:test_case_finished) do |event|
+            test_case, result = *event.attributes
+            observed_events << [:test_case_finished, test_case.name, result.to_sym]
+          end
+          event_bus.on(:test_step_starting) do |event|
+            test_step = event.test_step
+            observed_events << [:test_step_starting, test_step.name]
+          end
+          event_bus.on(:test_step_finished) do |event|
+            test_step, result = *event.attributes
+            observed_events << [:test_step_finished, test_step.name, result.to_sym]
+          end
+        end
+
+        expect(observed_events).to eq [
+          [:test_case_starting, 'The one that passes'],
+          [:test_step_starting, 'passing'],
+          [:test_step_finished, 'passing', :passed],
+          [:test_case_finished, 'The one that passes', :passed],
+          [:test_case_starting, 'The one that fails'],
+          [:test_step_starting, 'passing'],
+          [:test_step_finished, 'passing', :passed],
+          [:test_step_starting, 'failing'],
+          [:test_step_finished, 'failing', :failed],
+          [:test_step_starting, 'passing'],
+          [:test_step_finished, 'passing', :skipped],
+          [:test_step_starting, 'undefined'],
+          [:test_step_finished, 'undefined', :undefined],
+          [:test_case_finished, 'The one that fails', :failed],
+        ]
+      end
+
       context "without hooks" do
         it "executes the test cases in the suite" do
           gherkin = gherkin do
@@ -216,9 +272,10 @@ module Cucumber
               end
             end
           end
-          report = Core::Report::Summary.new
 
-          execute [gherkin], report, [Core::Test::Filters::ActivateStepsForSelfTest.new]
+          event_bus = Core::EventBus.new
+          report = Core::Report::Summary.new(event_bus)
+          execute [gherkin], [Core::Test::Filters::ActivateStepsForSelfTest.new], event_bus
 
           expect( report.test_cases.total           ).to eq 2
           expect( report.test_cases.total_passed    ).to eq 1
@@ -258,10 +315,11 @@ module Cucumber
               end
             end
           end
-          report = Core::Report::Summary.new
           logger = []
 
-          execute [gherkin], report, [WithAroundHooks.new(logger)]
+          event_bus = Core::EventBus.new
+          report = Core::Report::Summary.new(event_bus)
+          execute [gherkin], [WithAroundHooks.new(logger)], event_bus
 
           expect( report.test_cases.total        ).to eq 1
           expect( report.test_cases.total_passed ).to eq 1
@@ -293,9 +351,10 @@ module Cucumber
             end
           end
         end
-        report = Core::Report::Summary.new
 
-        execute [gherkin], report, [ Cucumber::Core::Test::TagFilter.new(['@a']) ]
+        event_bus = Core::EventBus.new
+        report = Core::Report::Summary.new(event_bus)
+        execute [gherkin], [ Cucumber::Core::Test::TagFilter.new(['@a']) ], event_bus
 
         expect( report.test_cases.total ).to eq 2
       end
@@ -311,9 +370,10 @@ module Cucumber
             end
           end
         end
-        report = Core::Report::Summary.new
 
-        execute [gherkin], report, [ Cucumber::Core::Test::NameFilter.new([/scenario/]) ]
+        event_bus = Core::EventBus.new
+        report = Core::Report::Summary.new(event_bus)
+        execute [gherkin], [ Cucumber::Core::Test::NameFilter.new([/scenario/]) ], event_bus
 
         expect( report.test_cases.total ).to eq 1
       end