cucumber-core 11.0.0 → 11.1.0

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

@@ -1,320 +0,0 @@
-# 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(:step_id)   { double }
-    let(:test_id)   { double }
-    let(:name)      { double }
-    let(:location)  { double }
-    let(:tags)      { double }
-    let(:language)  { double }
-    let(:test_case) { Case.new(test_id, 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(step_id, text, location, location).with_action {} }
-    let(:failing)   { Step.new(step_id, text, location, location).with_action { raise exception } }
-    let(:pending)   { Step.new(step_id, text, location, location).with_action { raise Result::Pending.new("TODO") } }
-    let(:skipping)  { Step.new(step_id, text, location, location).with_action { raise Result::Skipped.new } }
-    let(:undefined) { Step.new(step_id, 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(test_id, name, [failing], location, tags, language) }
-        let(:last_test_case)  { Case.new(test_id, 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(step_id, text, location, hook_mapping)
-        failing_step = Step.new(step_id, text, location).with_action { fail }
-        test_case = Case.new(test_id, 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(step_id, text, location, location).with_action {}
-        test_case = Case.new(test_id, 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(step_id, text, location, location).with_action {}
-        test_case = Case.new(test_id, 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(step_id, text, location, location).with_action {}
-        test_case = Case.new(test_id, 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(step_id, text, location, location).with_action { raise exception }
-        test_case = Case.new(test_id, 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(step_id, text, location, location).with_action {}
-        test_case = Case.new(test_id, 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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/step'
-
-module Cucumber::Core::Test
-  describe Step do
-    let(:id) { 'some-random-uid' }
-    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(id, 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(id, 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(id, 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(id, 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(id, 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(id, 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(id, 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(id, 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(id, text, location)
-      expect( test_step.to_s     ).to eq 'a passing step'
-    end
-
-  end
-end

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

@@ -1,25 +0,0 @@
-# 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

@@ -1,262 +0,0 @@
-# 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('some-random-uid', '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