cucumber-core 11.0.0 → 11.1.0

data/spec/cucumber/core/report/summary_spec.rb

@@ -1,178 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'cucumber/core/event_bus'
-require 'cucumber/core/events'
-require 'cucumber/core/report/summary'
-require 'cucumber/core/test/result'
-
-module Cucumber::Core::Report
-  describe Summary do
-    let(:event_bus) { ::Cucumber::Core::EventBus.new(registry) }
-    let(:registry) { ::Cucumber::Core::Events.registry }
-    let(:passed_result) { ::Cucumber::Core::Test::Result::Passed.new(duration) }
-    let(:failed_result) { ::Cucumber::Core::Test::Result::Failed.new(duration, exception) }
-    let(:pending_result) { ::Cucumber::Core::Test::Result::Pending.new(duration) }
-    let(:skipped_result) { ::Cucumber::Core::Test::Result::Skipped.new(duration) }
-    let(:undefined_result) { ::Cucumber::Core::Test::Result::Undefined.new(duration) }
-    let(:duration) { double }
-    let(:exception) { double }
-
-    before(:each) { @summary = Summary.new(event_bus) }
-
-    context "test case summary" do
-      let(:test_case) { double }
-
-      it "counts passed test cases" do
-        event_bus.send(:test_case_finished, test_case, passed_result)
-
-        expect( @summary.test_cases.total(:passed) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts failed test cases" do
-        event_bus.send(:test_case_finished, test_case, failed_result)
-
-        expect( @summary.test_cases.total(:failed) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts pending test cases" do
-        event_bus.send(:test_case_finished, test_case, pending_result)
-
-        expect( @summary.test_cases.total(:pending) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts skipped test cases" do
-        event_bus.send(:test_case_finished, test_case, skipped_result)
-
-        expect( @summary.test_cases.total(:skipped) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts undefined test cases" do
-        event_bus.send(:test_case_finished, test_case, undefined_result)
-
-        expect( @summary.test_cases.total(:undefined) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "handles flaky test cases" do
-        allow(test_case).to receive(:==).and_return(false, true)
-        event_bus.send(:test_case_finished, test_case, failed_result)
-        event_bus.send(:test_case_finished, test_case, passed_result)
-
-        expect( @summary.test_cases.total(:failed) ).to eq(0)
-        expect( @summary.test_cases.total(:flaky) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "handless flaky with following skip test cases" do
-        allow(test_case).to receive(:==).and_return(false, true)
-        event_bus.send(:test_case_finished, test_case, failed_result)
-        event_bus.send(:test_case_finished, test_case, skipped_result)
-
-        expect( @summary.test_cases.total(:failed) ).to eq(0)
-        expect( @summary.test_cases.total(:skipped) ).to eq(0)
-        expect( @summary.test_cases.total(:flaky) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-    end
-
-    context "test step summary" do
-      context "with test steps from gherkin steps" do
-        let(:test_step) { double }
-
-        before(:each) do
-          expect( test_step ).to receive(:hook?).and_return(false)
-        end
-
-        it "counts passed test steps" do
-          event_bus.send(:test_step_finished, test_step, passed_result)
-
-          expect( @summary.test_steps.total(:passed) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts failed test cases" do
-          event_bus.send(:test_step_finished, test_step, failed_result)
-
-          expect( @summary.test_steps.total(:failed) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts pending test cases" do
-          event_bus.send(:test_step_finished, test_step, pending_result)
-
-          expect( @summary.test_steps.total(:pending) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts skipped test cases" do
-          event_bus.send(:test_step_finished, test_step, skipped_result)
-
-          expect( @summary.test_steps.total(:skipped) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts undefined test cases" do
-          event_bus.send(:test_step_finished, test_step, undefined_result)
-
-          expect( @summary.test_steps.total(:undefined) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-      end
-
-      context "with test steps not from gherkin steps" do
-        let(:test_step) { double }
-
-        before(:each) do
-          expect( test_step ).to receive(:hook?).and_return(true)
-        end
-
-        it "ignores test steps not defined by gherkin steps" do
-          event_bus.send(:test_step_finished, test_step, passed_result)
-
-          expect( @summary.test_steps.total ).to eq(0)
-        end
-      end
-    end
-
-    context "ok? result" do
-      let(:test_case) { double }
-
-      it "passed test case is ok" do
-        event_bus.send(:test_case_finished, test_case, passed_result)
-
-        expect( @summary.ok? ).to eq true
-      end
-
-      it "skipped test case is ok" do
-        event_bus.send(:test_case_finished, test_case, skipped_result)
-
-        expect( @summary.ok? ).to eq true
-      end
-
-      it "failed test case is not ok" do
-        event_bus.send(:test_case_finished, test_case, failed_result)
-
-        expect( @summary.ok? ).to eq false
-      end
-
-      it "pending test case is ok if not strict" do
-        event_bus.send(:test_case_finished, test_case, pending_result)
-
-        expect( @summary.ok? ).to eq true
-        be_strict = ::Cucumber::Core::Test::Result::StrictConfiguration.new([:pending])
-        expect( @summary.ok?(be_strict) ).to eq false
-      end
-
-      it "undefined test case is ok if not strict" do
-        event_bus.send(:test_case_finished, test_case, undefined_result)
-
-        expect( @summary.ok? ).to eq true
-        be_strict = ::Cucumber::Core::Test::Result::StrictConfiguration.new([:undefined])
-        expect( @summary.ok?(be_strict) ).to eq false
-      end
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/action'
-require 'cucumber/core/test/duration_matcher'
-
-module Cucumber
-  module Core
-    module Test
-
-      describe Action do
-
-        context "constructed without a block" do
-          it "raises an error" do
-            expect { Action.new }.to raise_error(ArgumentError)
-          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 Test::Location.new(*block.source_location)
-            end
-          end
-
-        end
-
-        context "executing" do
-          it "executes the block passed to the constructor" do
-            executed = false
-            action = Action.new { executed = true }
-            action.execute
-            expect( executed ).to be_truthy
-          end
-
-          it "returns a passed result if the block doesn't fail" do
-            action = Action.new {}
-            expect( action.execute ).to be_passed
-          end
-
-          it "returns a failed result when the block raises an error" do
-            exception = StandardError.new
-            action = Action.new { raise exception }
-            result = action.execute
-            expect( result ).to be_failed
-            expect( result.exception ).to eq exception
-          end
-
-          it "yields the args passed to #execute to the block" do
-            args = [double, double]
-            args_spy = nil
-            action = Action.new { |arg1, arg2| args_spy = [arg1, arg2] }
-            action.execute(*args)
-            expect(args_spy).to eq args
-          end
-
-          it "returns a pending result if a Result::Pending error is raised" do
-            exception = Result::Pending.new("TODO")
-            action = Action.new { raise exception }
-            result = action.execute
-            expect( result ).to be_pending
-            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")
-            action = Action.new { raise exception }
-            result = action.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")
-            action = Action.new { raise exception }
-            result = action.execute
-            expect( result ).to be_undefined
-            expect( result.message ).to eq "new step"
-          end
-
-          context "recording the duration" do
-            before do
-              allow( Timer::MonotonicTime ).to receive(:time_in_nanoseconds).and_return(525702744080000, 525702744080001)
-            end
-
-            it "records the nanoseconds duration of the execution on the result" do
-              action = Action.new { }
-              duration = action.execute.duration
-              expect( duration ).to be_duration 1
-            end
-
-            it "records the duration of a failed execution" do
-              action = Action.new { raise StandardError }
-              duration = action.execute.duration
-              expect( duration ).to be_duration 1
-            end
-          end
-
-        end
-
-        context "skipping" do
-          it "does not execute the block" do
-            executed = false
-            action = Action.new { executed = true }
-            action.skip
-            expect( executed ).to be_falsey
-          end
-
-          it "returns a skipped result" do
-            action = Action.new {}
-            expect( action.skip ).to be_skipped
-          end
-        end
-      end
-
-      describe UndefinedAction do
-        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
-          end
-        end
-
-        context "skipping" do
-          it "returns an undefined result" do
-            expect( action.skip ).to be_undefined
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core'
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core/platform'
-require 'cucumber/core/test/case'
-require 'unindent'
-
-module Cucumber
-  module Core
-    module Test
-      describe Case do
-        include Core
-        include Core::Gherkin::Writer
-
-        let(:id) { double }
-        let(:name) { double }
-        let(:location) { double }
-        let(:tags) { double }
-        let(:language) { double }
-        let(:test_case) { Test::Case.new(id, name, test_steps, location, tags, language) }
-        let(:test_steps) { [double, double] }
-
-        context 'describing itself' do
-          it "describes itself to a visitor" do
-            visitor = double
-            args = double
-            expect(visitor).to receive(:test_case).with(test_case, args)
-            test_case.describe_to(visitor, args)
-          end
-
-          it "asks each test_step to describe themselves to the visitor" do
-            visitor = double
-            args = double
-            test_steps.each do |test_step|
-              expect(test_step).to receive(:describe_to).with(visitor, args)
-            end
-            allow(visitor).to receive(:test_case).and_yield(visitor)
-            test_case.describe_to(visitor, args)
-          end
-
-          it "describes around hooks in order" do
-            visitor = double
-            allow(visitor).to receive(:test_case).and_yield(visitor)
-            first_hook = double
-            second_hook = double
-            expect(first_hook).to receive(:describe_to).ordered.and_yield
-            expect(second_hook).to receive(:describe_to).ordered.and_yield
-            around_hooks = [first_hook, second_hook]
-            Test::Case.new(id, name, [], location, tags, language, around_hooks).describe_to(visitor, double)
-          end
-        end
-
-        describe "#name" do
-          it "the name is passed when creating the test case" do
-            expect(test_case.name).to eq(name)
-          end
-        end
-
-        describe "#location" do
-          it "the location is passed when creating the test case" do
-            expect(test_case.location).to eq(location)
-          end
-        end
-
-        describe "#tags" do
-          it "the tags are passed when creating the test case" do
-            expect(test_case.tags).to eq(tags)
-          end
-        end
-
-        describe "matching tags" do
-          let(:tags) { ['@a', '@b', '@c'].map { |value| Tag.new(location, value) } }
-          it "matches tags using tag expressions" do
-            expect(test_case.match_tags?(['@a and @b'])).to be_truthy
-            expect(test_case.match_tags?(['@a or @d'])).to be_truthy
-            expect(test_case.match_tags?(['not @d'])).to be_truthy
-            expect(test_case.match_tags?(['@a and @d'])).to be_falsy
-          end
-
-          it "matches handles multiple expressions" do
-            expect(test_case.match_tags?(['@a and @b', 'not @d'])).to be_truthy
-            expect(test_case.match_tags?(['@a and @b', 'not @c'])).to be_falsy
-          end
-        end
-
-        describe "matching names" do
-          let(:name) { 'scenario' }
-          it "matches names against regexp" do
-            expect(test_case.match_name?(/scenario/)).to be_truthy
-          end
-        end
-
-        describe "#language" do
-          let(:language) { 'en-pirate' }
-          it "the language is passed when creating the test case" do
-            expect(test_case.language).to eq 'en-pirate'
-          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 'text'
-                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
-end

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

@@ -1,79 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'cucumber/core/test/data_table'
-
-module Cucumber
-  module Core
-    module Test
-      describe DataTable do
-        before do
-          @table = DataTable.new([
-            %w{one four seven},
-            %w{4444 55555 666666}
-          ])
-        end
-
-        describe "equality" do
-          it "is equal to another table with the same data" do
-            expect( DataTable.new([[1, 2], [3, 4]]) ).to eq DataTable.new([[1, 2], [3, 4]])
-          end
-
-          it "is not equal to another table with different data" do
-            expect( DataTable.new([[1, 2], [3, 4]]) ).not_to eq DataTable.new([[1, 2]])
-          end
-
-          it "is not equal to a non table" do
-            expect( DataTable.new([[1, 2], [3, 4]]) ).not_to eq Object.new
-          end
-        end
-
-        describe "#data_table?" do
-          let(:table) { DataTable.new([[1, 2], [3, 4]]) }
-
-          it "returns true" do
-            expect(table).to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          let(:table) { DataTable.new([[1, 2], [3, 4]]) }
-
-          it "returns false" do
-            expect(table).not_to be_doc_string
-          end
-        end
-
-        describe "#map" do
-          let(:table) { DataTable.new([ %w{foo bar}, %w{1 2} ]) }
-
-          it 'yields the contents of each cell to the block' do
-
-            expect { |b| table.map(&b) }.to yield_successive_args('foo', 'bar', '1', '2')
-          end
-
-          it 'returns a new table with the cells modified by the block' do
-            expect( table.map { |cell| "*#{cell}*" } ).to eq DataTable.new([%w{*foo* *bar*}, %w{*1* *2*}])
-          end
-        end
-
-        describe "#transpose" do
-          before(:each) do
-            @table = DataTable.new([
-              %w{one 1111},
-              %w{two 22222}
-            ])
-          end
-
-          it "should transpose the table" do
-            transposed = DataTable.new([
-              %w{one two},
-              %w{1111 22222}
-            ])
-            expect( @table.transpose ).to eq( transposed )
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/doc_string'
-require 'unindent'
-
-module Cucumber
-  module Core
-    module Test
-      describe DocString do
-        let(:doc_string) { DocString.new(content, content_type) }
-
-        describe "#data_table?" do
-          let(:doc_string) { DocString.new("test", "text/plain" ) }
-
-          it "returns false" do
-            expect(doc_string).not_to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          let(:doc_string) { DocString.new("test", "text/plain" ) }
-
-          it "returns true" do
-            expect(doc_string).to be_doc_string
-          end
-        end
-
-        context '#map' do
-          let(:content) { 'original content' }
-          let(:content_type) { double }
-
-          it 'yields with the content' do
-            expect { |b| doc_string.map(&b) }.to yield_with_args(content)
-          end
-
-          it 'returns a new docstring with new content' do
-            expect( doc_string.map { 'foo' }.content ).to eq 'foo'
-          end
-
-          it 'raises an error if no block is given' do
-            expect { doc_string.map }.to raise_error ArgumentError
-          end
-        end
-
-        context 'equality' do
-          let(:content) { 'foo' }
-          let(:content_type) { 'text/plain' }
-
-          it 'is equal to another DocString with the same content and content_type' do
-            expect( doc_string ).to eq DocString.new(content, content_type)
-          end
-
-          it 'is not equal to another DocString with different content' do
-            expect( doc_string ).not_to eq DocString.new('bar', content_type)
-          end
-
-          it 'is not equal to another DocString with different content_type' do
-            expect( doc_string ).not_to eq DocString.new(content, 'text/html')
-          end
-
-          it 'is equal to a string with the same content' do
-            expect( doc_string ).to eq 'foo'
-          end
-
-          it 'returns false when compared with something odd' do
-            expect( doc_string ).not_to eq 5
-          end
-        end
-
-        context 'quacking like a String' do
-          let(:content) { String.new('content') }
-          let(:content_type) { 'text/plain' }
-
-          it 'delegates #encoding to the content string' do
-            content.force_encoding('us-ascii')
-            expect( doc_string.encoding ).to eq Encoding.find('US-ASCII')
-          end
-
-          it 'allows implicit conversion to a String' do
-            expect( 'expected content' ).to include(doc_string)
-          end
-
-          it 'allows explicit conversion to a String' do
-            expect( doc_string.to_s ).to eq 'content'
-          end
-
-          it 'delegates #gsub to the content string' do
-            expect( doc_string.gsub(/n/, '_') ).to eq 'co_te_t'
-          end
-
-          it 'delegates #split to the content string' do
-            expect(doc_string.split('n')).to eq ['co', 'te', 't']
-          end
-        end
-      end
-
-      context "inspect" do
-        let(:content_type) { 'text/plain' }
-
-        it "provides a useful inspect method" do
-          doc_string = DocString.new("some text", content_type)
-          expect(doc_string.inspect).to eq <<-END.chomp.unindent
-          #<Cucumber::Core::Test::DocString
-            """text/plain
-            some text
-            """>
-          END
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/location'
-require 'cucumber/core/test/empty_multiline_argument'
-
-module Cucumber
-  module Core
-    module Test
-      describe EmptyMultilineArgument do
-
-        let(:location) { double }
-        let(:arg) { EmptyMultilineArgument.new }
-
-        describe "#data_table?" do
-          it "returns false" do
-            expect(arg).not_to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          it "returns false" do
-            expect(arg).not_to be_doc_string
-          end
-        end
-
-      end
-    end
-  end
-end