cucumber 3.0.1 → 3.2.0

data/spec/cucumber/filters/gated_receiver_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/filters/gated_receiver'
-
-describe Cucumber::Filters::GatedReceiver do
-  subject(:gated_receiver) { Cucumber::Filters::GatedReceiver.new(receiver) }
-
-  let(:receiver) { double(:receiver) }
-  let(:test_cases){ [double(:test_case), double(:test_case)] }
-
-  describe '#test_case' do
-    it 'does not immediately describe the test case to the receiver' do
-      test_cases.each do |test_case|
-        expect(test_case).to_not receive(:describe_to).with(receiver)
-      end
-
-      test_cases.each do |test_case|
-        gated_receiver.test_case(test_case)
-      end
-    end
-  end
-
-  describe '#done' do
-    before do
-      test_cases.each do |test_case|
-        gated_receiver.test_case(test_case)
-      end
-
-      test_cases.each do |test_case|
-        allow(test_case).to receive(:describe_to).with(receiver)
-      end
-
-      allow(receiver).to receive(:done)
-    end
-
-    it 'describes all test cases to the receiver' do
-      test_cases.each do |test_case|
-        expect(test_case).to receive(:describe_to).with(receiver)
-      end
-
-      gated_receiver.done
-    end
-
-    it 'calls done on the receiver' do
-      expect(receiver).to receive(:done)
-      gated_receiver.done
-    end
-  end
-end

data/spec/cucumber/filters/retry_spec.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber'
-require 'cucumber/filters/retry'
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/configuration'
-require 'cucumber/core/test/case'
-require 'cucumber/core'
-require 'cucumber/events'
-
-describe Cucumber::Filters::Retry do
-  include Cucumber::Core::Gherkin::Writer
-  include Cucumber::Core
-  include Cucumber::Events
-
-  let(:configuration) { Cucumber::Configuration.new(:retry => 2) }
-  let(:test_case) { Cucumber::Core::Test::Case.new([double('test steps')], double('source').as_null_object) }
-  let(:receiver) { double('receiver').as_null_object }
-  let(:filter) { Cucumber::Filters::Retry.new(configuration, receiver) }
-  let(:fail) { Cucumber::Events::AfterTestCase.new(test_case, double('result', :failed? => true, :ok? => false)) }
-  let(:pass) { Cucumber::Events::AfterTestCase.new(test_case, double('result', :failed? => false, :ok? => true)) }
-
-  it { is_expected.to respond_to(:test_case) }
-  it { is_expected.to respond_to(:with_receiver) }
-  it { is_expected.to respond_to(:done) }
-
-  context 'passing test case' do
-    let(:result) { Cucumber::Core::Test::Result::Passed.new(0) }
-
-    it 'describes the test case once' do
-      expect(receiver).to receive(:test_case).with(test_case).once
-      test_case.describe_to filter
-      configuration.notify :test_case_finished, test_case, result
-    end
-  end
-
-  context 'when performing retry' do
-    let(:result) { Cucumber::Core::Test::Result::Failed.new(0, StandardError.new) }
-
-    it 'describes the same test case object each time' do
-      allow(receiver).to receive(:test_case) {|tc|
-        expect(tc).to equal(test_case)
-        configuration.notify :test_case_finished, tc.with_steps(tc.test_steps), result
-      }
-
-      filter.test_case(test_case)
-    end
-  end
-
-  context 'consistently failing test case' do
-    let(:result) { Cucumber::Core::Test::Result::Failed.new(0, StandardError.new) }
-
-    it 'describes the test case the specified number of times' do
-      expect(receiver).to receive(:test_case) {|test_case|
-        configuration.notify :test_case_finished, test_case, result
-      }.exactly(3).times
-
-      filter.test_case(test_case)
-    end
-  end
-
-  context 'flaky test cases' do
-
-    context 'a little flaky' do
-      let(:results) {
-        [
-          Cucumber::Core::Test::Result::Failed.new(0, StandardError.new),
-          Cucumber::Core::Test::Result::Passed.new(0)
-        ]
-      }
-
-      it 'describes the test case twice' do
-        expect(receiver).to receive(:test_case) {|test_case|
-          configuration.notify :test_case_finished, test_case, results.shift
-        }.exactly(2).times
-
-        filter.test_case(test_case)
-      end
-    end
-
-    context 'really flaky' do
-      let(:results) {
-        [
-          Cucumber::Core::Test::Result::Failed.new(0, StandardError.new),
-          Cucumber::Core::Test::Result::Failed.new(0, StandardError.new),
-          Cucumber::Core::Test::Result::Passed.new(0)
-        ]
-      }
-
-      it 'describes the test case 3 times' do
-        expect(receiver).to receive(:test_case) {|test_case|
-          configuration.notify :test_case_finished, test_case, results.shift
-        }.exactly(3).times
-
-        filter.test_case(test_case)
-      end
-    end
-  end
-end

data/spec/cucumber/filters/tag_limits/test_case_index_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/filters/tag_limits'
-
-describe Cucumber::Filters::TagLimits::TestCaseIndex do
-  subject(:index) { Cucumber::Filters::TagLimits::TestCaseIndex.new }
-
-  let(:test_cases) do
-    [
-      double(:test_case, tags: [tag_one], location: a_location_of_tag_one),
-      double(:test_case, tags: [tag_one, tag_two], location: a_location_of_tag_one_and_tag_two)
-    ]
-  end
-
-  let(:tag_one) { double(:tag_one, name: '@one') }
-  let(:tag_two) { double(:tag_two, name: '@two') }
-
-  let(:a_location_of_tag_one) { double(:a_location_of_tag_one) }
-  let(:a_location_of_tag_one_and_tag_two) { double(:a_location_of_tag_one_and_tag_two) }
-
-  before do
-    test_cases.map do |test_case|
-      index.add(test_case)
-    end
-  end
-
-  describe '#count_by_tag_name' do
-    it 'returns the number of test cases with the tag' do
-      expect(index.count_by_tag_name('@one')).to eq(2)
-      expect(index.count_by_tag_name('@two')).to eq(1)
-    end
-  end
-
-  describe '#locations_by_tag_name' do
-    it 'returns the locations of test cases with the tag' do
-      expect(index.locations_of_tag_name('@one')).to eq([a_location_of_tag_one, a_location_of_tag_one_and_tag_two])
-      expect(index.locations_of_tag_name('@two')).to eq([a_location_of_tag_one_and_tag_two])
-    end
-  end
-end

data/spec/cucumber/filters/tag_limits/verifier_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/filters/tag_limits'
-
-describe Cucumber::Filters::TagLimits::Verifier do
-  describe '#verify!' do
-    subject(:verifier) { Cucumber::Filters::TagLimits::Verifier.new(tag_limits) }
-    let(:test_case_index) { double(:test_case_index) }
-
-    context 'the tag counts exceed the tag limits' do
-      let(:tag_limits) do
-        {
-          '@exceed_me' => 1
-        }
-      end
-
-      let(:locations) do
-        [
-          double(:location, to_s: 'path/to/some.feature:3'),
-          double(:location, to_s: 'path/to/some/other.feature:8')
-        ]
-      end
-
-      before do
-        allow(test_case_index).to receive(:count_by_tag_name).with('@exceed_me') { 2 }
-        allow(test_case_index).to receive(:locations_of_tag_name).with('@exceed_me') { locations }
-      end
-
-      it 'raises a TagLimitExceeded error with the locations of the tags' do
-        expect {
-          verifier.verify!(test_case_index)
-        }.to raise_error(
-          Cucumber::Filters::TagLimitExceededError,
-          "@exceed_me occurred 2 times, but the limit was set to 1\n" +
-          "  path/to/some.feature:3\n" +
-          '  path/to/some/other.feature:8'
-        )
-      end
-    end
-
-    context 'the tag counts do not exceed the tag limits' do
-      let(:tag_limits) do
-        {
-          '@dont_exceed_me' => 2
-        }
-      end
-
-      before do
-        allow(test_case_index).to receive(:count_by_tag_name).with('@dont_exceed_me') { 1 }
-      end
-
-      it 'does not raise an error' do
-        expect {
-          verifier.verify!(test_case_index)
-        }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/cucumber/filters/tag_limits_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/filters/tag_limits'
-
-describe Cucumber::Filters::TagLimits do
-  subject(:filter) { Cucumber::Filters::TagLimits.new(tag_limits, receiver) }
-
-  let(:tag_limits) { double(:tag_limits) }
-  let(:receiver) { double(:receiver) }
-
-  let(:gated_receiver) { double(:gated_receiver) }
-  let(:test_case_index) { double(:test_case_index) }
-  let(:test_case) { double(:test_case) }
-
-  before do
-    allow(Cucumber::Filters::GatedReceiver).to receive(:new).with(receiver) { gated_receiver }
-    allow(Cucumber::Filters::TagLimits::TestCaseIndex).to receive(:new) { test_case_index }
-  end
-
-  describe '#test_case' do
-    before do
-      allow(test_case_index).to receive(:add)
-      allow(gated_receiver).to receive(:test_case)
-    end
-
-    it 'indexes the test case' do
-      expect(test_case_index).to receive(:add).with(test_case)
-      filter.test_case(test_case)
-    end
-
-    it 'adds the test case to the gated receiver' do
-      expect(gated_receiver).to receive(:test_case).with(test_case)
-      filter.test_case(test_case)
-    end
-  end
-
-  describe '#done' do
-    let(:verifier) { double(:verifier) }
-
-    before do
-      allow(Cucumber::Filters::TagLimits::Verifier).to receive(:new).with(tag_limits) { verifier }
-      allow(gated_receiver).to receive(:done)
-    end
-
-    it 'verifies tag limits have not been exceeded' do
-      expect(verifier).to receive(:verify!).with(test_case_index)
-      filter.done
-    end
-
-    context 'the verifier verifies successfully' do
-      before do
-        allow(verifier).to receive(:verify!).with(test_case_index)
-      end
-
-      it 'calls done on the receiver gate' do
-        expect(gated_receiver).to receive(:done)
-        filter.done
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/formatter/ansicolor'
-
-module Cucumber
-  module Formatter
-    describe ANSIColor do
-      include ANSIColor
-
-      it 'wraps passed_param with bold green and reset to green' do
-        expect(passed_param('foo')).to eq "\e[32m\e[1mfoo\e[0m\e[0m\e[32m"
-      end
-
-      it 'wraps passed in green' do
-        expect(passed('foo')).to eq "\e[32mfoo\e[0m"
-      end
-
-      it 'does not reset passed if there are no arguments' do
-        expect(passed).to eq "\e[32m"
-      end
-
-      it 'wraps comments in grey' do
-        expect(comment('foo')).to eq "\e[90mfoo\e[0m"
-      end
-
-      it 'does not generate ansi codes when colors are disabled' do
-        ::Cucumber::Term::ANSIColor.coloring = false
-
-        expect(passed('foo')).to eq 'foo'
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/backtrace_filter_spec.rb

@@ -1,32 +0,0 @@
-require 'cucumber/formatter/backtrace_filter'
-
-module Cucumber
-  module Formatter
-    describe BacktraceFilter do
-      context '#exception' do
-        before do
-          trace = %w(a b
-                     _anything__/vendor/rails__anything_
-                     _anything__lib/cucumber__anything_
-                     _anything__bin/cucumber:__anything_
-                     _anything__lib/rspec__anything_
-                     _anything__gems/__anything_
-                     _anything__minitest__anything_
-                     _anything__test/unit__anything_
-                     _anything__Xgem/ruby__anything_
-                     _anything__lib/ruby/__anything_
-                     _anything__.rbenv/versions/2.3/bin/bundle__anything_)
-          @exception = Exception.new
-          @exception.set_backtrace(trace)
-        end
-
-        it 'filters unnecessary traces' do
-          BacktraceFilter.new(@exception).exception
-          expect(@exception.backtrace).to eql %w(a b)
-        end
-      end
-    end
-  end
-end
-
-

data/spec/cucumber/formatter/console_counts_spec.rb

@@ -1,14 +0,0 @@
-require 'cucumber/configuration'
-require 'cucumber/formatter/console_counts'
-
-module Cucumber
-  module Formatter
-    describe ConsoleCounts do
-      it 'works for zero' do
-        config = Configuration.new
-        counts = ConsoleCounts.new(config)
-        expect(counts.to_s).to eq "0 scenarios\n0 steps"
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/duration_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/formatter/duration'
-
-module Cucumber
-  module Formatter
-    describe Duration do
-      include Duration
-
-      it 'formats ms' do
-        expect(format_duration(0.002103)).to eq '0m0.002s'
-      end
-
-      it 'formats m' do
-        expect(format_duration(61.002503)).to eq'1m1.003s'
-      end
-
-      it 'formats h' do
-        expect(format_duration(3661.002503)).to eq '61m1.003s'
-      end
-    end
-  end
-end

data/spec/cucumber/formatter/fail_fast_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/formatter/fail_fast'
-require 'cucumber/core'
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core/test/result'
-require 'cucumber/core/filter'
-require 'cucumber/core/ast'
-require 'cucumber'
-require 'support/standard_step_actions'
-
-module Cucumber::Formatter
-  describe FailFast do
-    include Cucumber::Core
-    include Cucumber::Core::Gherkin::Writer
-
-    let(:configuration) { Cucumber::Configuration.new }
-    before { FailFast.new(configuration) }
-
-    context 'failing scenario' do
-      before(:each) do
-        @gherkin = gherkin('foo.feature') do
-          feature do
-            scenario do
-              step 'failing'
-            end
-
-            scenario do
-              step 'failing'
-            end
-          end
-        end
-      end
-
-      after(:each) do
-        Cucumber.wants_to_quit = false
-      end
-
-      it 'sets Cucumber.wants_to_quit' do
-        execute [@gherkin], [StandardStepActions.new], configuration.event_bus
-        expect(Cucumber.wants_to_quit).to be true
-      end
-    end
-
-    context 'passing scenario' do
-      before(:each) do
-        @gherkin = gherkin('foo.feature') do
-          feature do
-            scenario do
-              step 'passing'
-            end
-          end
-        end
-      end
-
-      it 'doesn\'t set Cucumber.wants_to_quit' do
-        execute [@gherkin], [StandardStepActions.new], configuration.event_bus
-        expect(Cucumber.wants_to_quit).to be_falsey
-      end
-    end
-
-    context 'undefined scenario' do
-      before(:each) do
-        @gherkin = gherkin('foo.feature') do
-          feature do
-            scenario do
-              step 'undefined'
-            end
-          end
-        end
-      end
-
-      it 'doesn\'t set Cucumber.wants_to_quit' do
-        execute [@gherkin], [StandardStepActions.new], configuration.event_bus
-        expect(Cucumber.wants_to_quit).to be_falsey
-      end
-
-      context 'in strict mode' do
-        let(:configuration) { Cucumber::Configuration.new strict: Cucumber::Core::Test::Result::StrictConfiguration.new([:undefined]) }
-
-        it 'sets Cucumber.wants_to_quit' do
-          execute [@gherkin], [StandardStepActions.new], configuration.event_bus
-          expect(Cucumber.wants_to_quit).to be_truthy
-        end
-      end
-    end
-
-  end
-end