cucumber-core 4.0.0 → 5.0.0

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

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/runner'
+require 'cucumber/core/test/case'
+require 'cucumber/core/test/step'
+require 'cucumber/core/test/duration_matcher'
+
+module Cucumber::Core::Test
+  describe Runner do
+
+    let(:name)      { double }
+    let(:location)  { double }
+    let(:tags)      { double }
+    let(:language)  { double }
+    let(:test_case) { Case.new(name, test_steps, location, tags, language) }
+    let(:text)      { double }
+    let(:runner)    { Runner.new(event_bus) }
+    let(:event_bus) { double.as_null_object }
+    let(:passing)   { Step.new(text, location, location).with_action {} }
+    let(:failing)   { Step.new(text, location, location).with_action { raise exception } }
+    let(:pending)   { Step.new(text, location, location).with_action { raise Result::Pending.new("TODO") } }
+    let(:skipping)  { Step.new(text, location, location).with_action { raise Result::Skipped.new } }
+    let(:undefined) { Step.new(text, location, location) }
+    let(:exception) { StandardError.new('test error') }
+
+    before do
+      allow( event_bus ).to receive(:test_case_started)
+      allow( text ).to receive(:empty?)
+    end
+
+    context "reporting the duration of a test case" do
+      before do
+        allow( Timer::MonotonicTime ).to receive(:time_in_nanoseconds).and_return(525702744080000, 525702744080001)
+      end
+
+      context "for a passing test case" do
+        let(:test_steps) { [passing] }
+
+        it "records the nanoseconds duration of the execution on the result" do
+          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
+      end
+
+      context "for a failing test case" do
+        let(:test_steps) { [failing] }
+
+        it "records the duration" do
+          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
+      end
+    end
+
+    context "reporting the exception that failed a test case" do
+      let(:test_steps) { [failing] }
+      it "sets the exception on the result" do
+        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
+      end
+    end
+
+    context "with a single case" do
+      context "without steps" do
+        let(:test_steps) { [] }
+
+        it "emits a test_case_started event before running the test case" do
+          expect(event_bus).to receive(:test_case_started).with(test_case)
+          test_case.describe_to runner
+        end
+
+        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_undefined
+          end
+          test_case.describe_to runner
+        end
+      end
+
+      context 'with steps' do
+        context 'that all pass' do
+          let(:test_steps) { [ passing, passing ]  }
+
+          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
+          end
+        end
+
+        context 'an undefined step' do
+          let(:test_steps) { [ undefined ]  }
+
+          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
+
+            test_case.describe_to runner
+          end
+
+          it 'sets the message on the result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.message ).to eq("Undefined step: \"step name\"")
+            end
+            allow( undefined ).to receive(:text).and_return('step name')
+
+            test_case.describe_to runner
+          end
+
+          it 'appends the backtrace of the result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.backtrace ).to eq(["step line"])
+            end
+            expect( undefined ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context 'a pending step' do
+          let(:test_steps) { [ pending ] }
+
+          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(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.backtrace.last ).to eq("step line")
+            end
+            expect( pending ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context "a skipping step" do
+          let(:test_steps) { [skipping] }
+
+          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(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.backtrace.last ).to eq("step line")
+            end
+            expect( skipping ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context 'that fail' do
+          let(:test_steps) { [ failing ] }
+
+          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(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.exception.backtrace.last ).to eq("step line")
+            end
+            expect( failing ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context 'where the first step fails' do
+          let(:test_steps) { [ failing, passing ] }
+
+          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 '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 '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
+            test_case.describe_to runner
+          end
+
+          it 'skips, rather than executing the second step' do
+            expect( passing ).not_to receive(:execute)
+            expect( passing ).to receive(:skip).and_return(Result::Skipped.new)
+            test_case.describe_to runner
+          end
+        end
+
+      end
+    end
+
+    context 'with multiple test cases' do
+      context 'when the first test case fails' do
+        let(:first_test_case) { Case.new(name, [failing], location, tags, language) }
+        let(:last_test_case)  { Case.new(name, [passing], location, tags, language) }
+        let(:test_cases)      { [first_test_case, last_test_case] }
+
+        it 'reports the results correctly for the following test case' do
+          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
+      end
+    end
+
+    context "passing latest result to a mapping" do
+      it "passes a Failed result when the scenario is failing" do
+        result_spy = nil
+        hook_mapping = UnskippableAction.new do |last_result|
+          result_spy = last_result
+        end
+        after_hook = HookStep.new(text, location, hook_mapping)
+        failing_step = Step.new(text, location).with_action { fail }
+        test_case = Case.new(name, [failing_step, after_hook], location, tags, language)
+        test_case.describe_to runner
+        expect(result_spy).to be_failed
+      end
+    end
+
+    require 'cucumber/core/test/around_hook'
+    context "with around hooks" do
+      it "passes normally when around hooks don't fail" do
+        around_hook = AroundHook.new { |block| block.call }
+        passing_step = Step.new(text, location, location).with_action {}
+        test_case = Case.new(name, [passing_step], location, tags, language, [around_hook])
+        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
+      end
+
+      it "gets a failed result if the Around hook fails before the test case is run" do
+        around_hook = AroundHook.new { |block| raise exception }
+        passing_step = Step.new(text, location, location).with_action {}
+        test_case = Case.new(name, [passing_step], location, tags, language, [around_hook])
+        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
+        test_case.describe_to runner
+      end
+
+      it "gets a failed result if the Around hook fails after the test case is run" do
+        around_hook = AroundHook.new { |block| block.call; raise exception }
+        passing_step = Step.new(text, location, location).with_action {}
+        test_case = Case.new(name, [passing_step], location, tags, language, [around_hook])
+        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
+        test_case.describe_to runner
+      end
+
+      it "fails when a step fails if the around hook works" do
+        around_hook = AroundHook.new { |block| block.call }
+        failing_step = Step.new(text, location, location).with_action { raise exception }
+        test_case = Case.new(name, [failing_step], location, tags, language, [around_hook])
+        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
+        test_case.describe_to runner
+      end
+
+      it "sends after_test_step for a step interrupted by (a timeout in) the around hook" do
+        around_hook = AroundHook.new { |block| block.call; raise exception }
+        passing_step = Step.new(text, location, location).with_action {}
+        test_case = Case.new(name, [], location, tags, language, [around_hook])
+        allow(runner).to receive(:running_test_step).and_return(passing_step)
+        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(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
+        test_case.describe_to runner
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/step'
+
+module Cucumber::Core::Test
+  describe Step do
+    let(:text) { 'step text' }
+    let(:location) { double }
+
+    describe "describing itself" do
+      it "describes itself to a visitor" do
+        visitor = double
+        args = double
+        test_step = Step.new(text, location)
+        expect( visitor ).to receive(:test_step).with(test_step, args)
+        test_step.describe_to(visitor, args)
+      end
+    end
+
+    describe "backtrace line" do
+      let(:text) { 'this step passes' }
+      let(:location)  { Location.new('path/file.feature', 10) }
+      let(:test_step) { Step.new(text, location) }
+
+      it "knows how to form the backtrace line" do
+        expect( test_step.backtrace_line ).to eq("path/file.feature:10:in `this step passes'")
+      end
+    end
+
+    describe "executing" do
+      it "passes arbitrary arguments to the action's block" do
+        args_spy = nil
+        expected_args = [double, double]
+        test_step = Step.new(text, location).with_action do |*actual_args|
+          args_spy = actual_args
+        end
+        test_step.execute(*expected_args)
+        expect(args_spy).to eq expected_args
+      end
+
+      context "when a passing action exists" do
+        it "returns a passing result" do
+          test_step = Step.new(text, location).with_action {}
+          expect( test_step.execute ).to be_passed
+        end
+      end
+
+      context "when a failing action exists" do
+        let(:exception) { StandardError.new('oops') }
+
+        it "returns a failing result" do
+          test_step = Step.new(text, location).with_action { raise exception }
+          result = test_step.execute
+          expect( result           ).to be_failed
+          expect( result.exception ).to eq exception
+        end
+      end
+
+      context "with no action" do
+        it "returns an Undefined result" do
+          test_step = Step.new(text, location)
+          result = test_step.execute
+          expect( result           ).to be_undefined
+        end
+      end
+    end
+
+    it "exposes the text and location of as attributes" do
+      test_step = Step.new(text, location)
+      expect( test_step.text              ).to eq text
+      expect( test_step.location          ).to eq location
+    end
+
+    it "exposes the location of the action as attribute" do
+      location = double
+      action = double(location: location)
+      test_step = Step.new(text, location, action)
+      expect( test_step.action_location ).to eq location
+    end
+
+    it "returns the text when converted to a string" do
+      text = 'a passing step'
+      test_step = Step.new(text, location)
+      expect( test_step.to_s     ).to eq 'a passing step'
+    end
+
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/timer'
+require 'cucumber/core/test/duration_matcher'
+
+module Cucumber
+  module Core
+    module Test
+      describe Timer do
+        before do
+          allow(Timer::MonotonicTime).to receive(:time_in_nanoseconds)
+                                            .and_return(525702744080000, 525702744080001)
+        end
+
+        it "returns a Result::Duration object" do
+          timer = Timer.new.start
+          expect( timer.duration ).to be_duration 1
+        end
+
+        it "would be slow to test" do
+          # so we won't
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/core_spec.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+require 'report_api_spy'
+require 'cucumber/core'
+require 'cucumber/core/filter'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core/platform'
+require 'cucumber/core/report/summary'
+require 'cucumber/core/test/around_hook'
+require 'cucumber/core/test/filters/activate_steps_for_self_test'
+
+module Cucumber
+  describe Core do
+    include Core
+    include Core::Gherkin::Writer
+
+    describe "compiling features to a test suite" do
+
+      it "compiles two scenarios into two test cases" do
+        visitor = ReportAPISpy.new
+
+        compile([
+          gherkin do
+            feature do
+              background do
+                step 'text'
+              end
+              scenario do
+                step 'text'
+              end
+              scenario do
+                step 'text'
+                step 'text'
+              end
+            end
+          end
+        ], visitor)
+
+        expect( visitor.messages ).to eq [
+          :test_case,
+          :test_step,
+          :test_step,
+          :test_case,
+          :test_step,
+          :test_step,
+          :test_step,
+          :done,
+        ]
+      end
+
+      it "filters out test cases based on a tag expression" do
+        visitor = double.as_null_object
+        expect( visitor ).to receive(:test_case) do |test_case|
+          expect( test_case.name ).to eq 'foo'
+        end.exactly(1).times
+
+        gherkin = gherkin do
+          feature do
+            scenario tags: '@b' do
+              step 'text'
+            end
+
+            scenario_outline 'foo' do
+              step '<arg>'
+
+              examples tags: '@a'do
+                row 'arg'
+                row 'x'
+              end
+
+              examples 'bar', tags: '@a @b' do
+                row 'arg'
+                row 'y'
+              end
+            end
+          end
+        end
+
+        compile [gherkin], visitor, [Cucumber::Core::Test::TagFilter.new(['@a', '@b'])]
+      end
+    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_started) do |event|
+            test_case = event.test_case
+            observed_events << [:test_case_started, 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_started) do |event|
+            test_step = event.test_step
+            observed_events << [:test_step_started, test_step.text]
+          end
+          event_bus.on(:test_step_finished) do |event|
+            test_step, result = *event.attributes
+            observed_events << [:test_step_finished, test_step.text, result.to_sym]
+          end
+        end
+
+        expect(observed_events).to eq [
+          [:test_case_started, 'The one that passes'],
+          [:test_step_started, 'passing'],
+          [:test_step_finished, 'passing', :passed],
+          [:test_case_finished, 'The one that passes', :passed],
+          [:test_case_started, 'The one that fails'],
+          [:test_step_started, 'passing'],
+          [:test_step_finished, 'passing', :passed],
+          [:test_step_started, 'failing'],
+          [:test_step_finished, 'failing', :failed],
+          [:test_step_started, 'passing'],
+          [:test_step_finished, 'passing', :skipped],
+          [:test_step_started, '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
+            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
+
+          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
+          expect( report.test_cases.total_failed    ).to eq 1
+          expect( report.test_steps.total           ).to eq 5
+          expect( report.test_steps.total_failed    ).to eq 1
+          expect( report.test_steps.total_passed    ).to eq 2
+          expect( report.test_steps.total_skipped   ).to eq 1
+          expect( report.test_steps.total_undefined ).to eq 1
+        end
+      end
+
+      context "with around hooks" do
+        class WithAroundHooks < Core::Filter.new(:logger)
+          def test_case(test_case)
+            base_step = Core::Test::Step.new('text', nil, nil, nil)
+            test_steps = [
+              base_step.with_action { logger << :step },
+            ]
+
+            around_hook = Core::Test::AroundHook.new do |run_scenario|
+              logger << :before_all
+              run_scenario.call
+              logger << :middle
+              run_scenario.call
+              logger << :after_all
+            end
+            test_case.with_steps(test_steps).with_around_hooks([around_hook]).describe_to(receiver)
+          end
+        end
+
+        it "executes the test cases in the suite" do
+          gherkin = gherkin do
+            feature do
+              scenario do
+                step 'text'
+              end
+            end
+          end
+          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
+          expect( report.test_cases.total_failed ).to eq 0
+          expect( logger ).to eq [
+            :before_all,
+              :step,
+            :middle,
+              :step,
+            :after_all
+          ]
+        end
+      end
+
+      require 'cucumber/core/test/filters'
+      it "filters test cases by tag" do
+        gherkin = gherkin do
+          feature do
+            scenario do
+              step 'text'
+            end
+
+            scenario tags: '@a @b' do
+              step 'text'
+            end
+
+            scenario tags: '@a' do
+              step 'text'
+            end
+          end
+        end
+
+        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
+
+      it "filters test cases by name" do
+        gherkin = gherkin do
+          feature 'first feature' do
+            scenario 'first scenario' do
+              step 'missing'
+            end
+            scenario 'second' do
+              step 'missing'
+            end
+          end
+        end
+
+        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
+
+    end
+  end
+end