cucumber 3.0.0 → 3.1.0

data/spec/cucumber/configuration_spec.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Cucumber
-  describe Configuration do
-    describe '.default' do
-      subject { Configuration.default }
-
-      it 'has an autoload_code_paths containing the standard support and step_definitions folders' do
-        expect(subject.autoload_code_paths).to include('features/support')
-        expect(subject.autoload_code_paths).to include('features/step_definitions')
-      end
-    end
-
-    describe 'with custom user options' do
-      let(:user_options) { { :autoload_code_paths => ['foo/bar/baz'] } }
-      subject { Configuration.new(user_options) }
-
-      it 'allows you to override the defaults' do
-        expect(subject.autoload_code_paths).to eq ['foo/bar/baz']
-      end
-    end
-
-    context 'selecting files to load' do
-
-      def given_the_following_files(*files)
-        allow(File).to receive(:directory?) { true }
-        allow(File).to receive(:file?) { true }
-        allow(Dir).to receive(:[]) { files }
-      end
-
-      it 'requires env.rb files first' do
-        configuration = Configuration.new
-        given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
-
-        expect(configuration.support_to_load).to eq [
-          '/features/support/env.rb',
-          '/features/support/a_file.rb'
-        ]
-      end
-
-      it 'does not require env.rb files when dry run' do
-        configuration = Configuration.new(dry_run: true)
-        given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
-
-        expect(configuration.support_to_load).to eq [
-          '/features/support/a_file.rb'
-        ]
-      end
-
-      it 'requires step defs in vendor/{plugins,gems}/*/cucumber/*.rb' do
-        given_the_following_files('/vendor/gems/gem_a/cucumber/bar.rb',
-                                  '/vendor/plugins/plugin_a/cucumber/foo.rb')
-
-        configuration = Configuration.new
-
-        expect(configuration.step_defs_to_load).to eq [
-          '/vendor/gems/gem_a/cucumber/bar.rb',
-          '/vendor/plugins/plugin_a/cucumber/foo.rb'
-        ]
-      end
-
-      describe '--exclude' do
-
-        it 'excludes a ruby file from requiring when the name matches exactly' do
-          given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
-
-          configuration = Configuration.new(excludes: [/a_file.rb/])
-
-          expect(configuration.all_files_to_load).to eq [
-            '/features/support/env.rb'
-          ]
-        end
-
-        it 'excludes all ruby files that match the provided patterns from requiring' do
-          given_the_following_files('/features/support/foof.rb','/features/support/bar.rb',
-                                    '/features/support/food.rb','/features/blah.rb',
-                                    '/features/support/fooz.rb')
-
-          configuration = Configuration.new(excludes: [/foo[df]/, /blah/])
-
-          expect(configuration.all_files_to_load).to eq [
-            '/features/support/bar.rb',
-            '/features/support/fooz.rb'
-          ]
-        end
-      end
-
-    end
-
-    context 'selecting feature files' do
-
-      it 'preserves the order of the feature files' do
-        configuration = Configuration.new(paths: %w{b.feature c.feature a.feature})
-
-        expect(configuration.feature_files).to eq ['b.feature', 'c.feature', 'a.feature']
-      end
-
-      it 'searchs for all features in the specified directory' do
-        allow(File).to receive(:directory?) { true }
-        allow(Dir).to receive(:[]).with('feature_directory/**/*.feature') { ['cucumber.feature'] }
-
-        configuration = Configuration.new(paths: %w{feature_directory/})
-
-        expect(configuration.feature_files).to eq ['cucumber.feature']
-      end
-
-      it 'defaults to the features directory when no feature file are provided' do
-        allow(File).to receive(:directory?) { true }
-        allow(Dir).to receive(:[]).with('features/**/*.feature') { ['cucumber.feature'] }
-
-        configuration = Configuration.new(paths: [])
-
-        expect(configuration.feature_files).to eq ['cucumber.feature']
-      end
-
-      it 'gets the feature files from the rerun file' do
-        allow(File).to receive(:directory?).and_return(false)
-        allow(File).to receive(:file?).and_return(true)
-        allow(IO).to receive(:read).and_return(
-          "cucumber.feature:1:3\ncucumber.feature:5 cucumber.feature:10\n"\
-          "domain folder/different cuke.feature:134 domain folder/cuke.feature:1\n"\
-          'domain folder/different cuke.feature:4:5 bar.feature')
-
-        configuration = Configuration.new(paths: %w{@rerun.txt})
-
-        expect(configuration.feature_files).to eq [
-          'cucumber.feature:1:3',
-          'cucumber.feature:5',
-          'cucumber.feature:10',
-          'domain folder/different cuke.feature:134',
-          'domain folder/cuke.feature:1',
-          'domain folder/different cuke.feature:4:5',
-          'bar.feature']
-      end
-    end
-
-    describe '#with_options' do
-      it 'returns a copy of the configuration with new options' do
-        old_out_stream = double('Old out_stream')
-        new_out_stream = double('New out_stream')
-        config = Configuration.new(out_stream: old_out_stream).with_options(out_stream: new_out_stream)
-        expect(config.out_stream).to eq new_out_stream
-      end
-    end
-
-  end
-end

data/spec/cucumber/constantize_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Html end
-
-module Cucumber
-  describe Constantize do
-    include Constantize
-
-    it 'loads html formatter' do
-      clazz = constantize('Cucumber::Formatter::Html')
-
-      expect(clazz.name).to eq 'Cucumber::Formatter::Html'
-    end
-
-    it 'fails to load a made up class' do
-      expect { constantize('My::MadeUp::ClassName') }.to raise_error(LoadError)
-    end
-  end
-end

data/spec/cucumber/events_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  describe Events do
-    it 'builds a registry without failing' do
-      expect { described_class.registry }.not_to raise_error
-    end
-  end
-end

data/spec/cucumber/file_specs_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/file_specs'
-
-module Cucumber
-  describe FileSpecs do
-    let(:file_specs) { FileSpecs.new(['features/foo.feature:1:2:3', 'features/bar.feature:4:5:6']) }
-    let(:locations) { file_specs.locations }
-    let(:files) { file_specs.files }
-
-    it 'parses locations from multiple files' do
-      expect(locations.length).to eq 6
-      expect(locations).to eq [
-        Cucumber::Core::Ast::Location.new('features/foo.feature', 1),
-        Cucumber::Core::Ast::Location.new('features/foo.feature', 2),
-        Cucumber::Core::Ast::Location.new('features/foo.feature', 3),
-        Cucumber::Core::Ast::Location.new('features/bar.feature', 4),
-        Cucumber::Core::Ast::Location.new('features/bar.feature', 5),
-        Cucumber::Core::Ast::Location.new('features/bar.feature', 6)
-      ]
-    end
-
-    it 'parses file names from multiple file specs' do
-      expect(files.length).to eq 2
-      expect(files).to eq [
-        'features/foo.feature',
-        'features/bar.feature'
-      ]
-    end
-
-    context 'when files are not unique' do
-      let(:file_specs) { FileSpecs.new(['features/foo.feature:4', 'features/foo.feature:34']) }
-
-      it 'parses unique file names' do
-        expect(files.length).to eq 1
-        expect(files).to eq ['features/foo.feature']
-      end
-    end
-
-    context 'when no line number is specified' do
-      let(:file_specs) { FileSpecs.new(['features/foo.feature', 'features/bar.feature:34']) }
-
-      it 'returns a wildcard location for that file' do
-        expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new('features/foo.feature'),
-          Cucumber::Core::Ast::Location.new('features/bar.feature', 34)
-        ]
-      end
-    end
-
-    context 'when the same file is referenced more than once' do
-      let(:file_specs) { FileSpecs.new(['features/foo.feature:10', 'features/foo.feature:1']) }
-
-      it 'returns locations in the order specified' do
-        expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new('features/foo.feature', 10),
-          Cucumber::Core::Ast::Location.new('features/foo.feature', 1)
-        ]
-      end
-    end
-  end
-end

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/filters/activate_steps'
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core'
-
-describe Cucumber::Filters::ActivateSteps do
-  include Cucumber::Core::Gherkin::Writer
-  include Cucumber::Core
-
-  let(:step_match) { double(activate: activated_test_step) }
-  let(:activated_test_step) { double }
-  let(:receiver) { double.as_null_object }
-  let(:filter) { Cucumber::Filters::ActivateSteps.new(step_match_search, configuration) }
-  let(:step_match_search) { Proc.new { [step_match] } }
-  let(:configuration) { double(dry_run?: false, notify: nil) }
-
-  context 'a scenario with a single step' do
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario do
-            step 'a passing step'
-          end
-        end
-      end
-    end
-
-    it 'activates each step' do
-      expect(step_match).to receive(:activate) do |test_step|
-        expect(test_step.text).to eq 'a passing step'
-      end
-      compile [doc], receiver, [filter]
-    end
-
-    it 'notifies with a StepActivated event' do
-      expect(configuration).to receive(:notify) do |message, test_step, step_match|
-        expect(message).to eq :step_activated
-        expect(test_step.text).to eq 'a passing step'
-        expect(step_match).to eq step_match
-      end
-      compile [doc], receiver, [filter]
-    end
-  end
-
-  context 'a scenario outline' do
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario_outline do
-            step 'a <status> step'
-
-            examples do
-              row 'status'
-              row 'passing'
-            end
-          end
-        end
-      end
-    end
-
-    it 'activates each step' do
-      expect(step_match).to receive(:activate) do |test_step|
-        expect(test_step.text).to eq 'a passing step'
-      end
-      compile [doc], receiver, [filter]
-    end
-  end
-
-  context 'undefined step' do
-    let(:step_match_search) { Proc.new { [] } }
-
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario do
-            step 'an undefined step'
-          end
-        end
-      end
-    end
-
-    it 'does not activate the step' do
-      expect(receiver).to receive(:test_case) do |test_case|
-        expect(test_case.test_steps[0].execute).to be_undefined
-      end
-      compile [doc], receiver, [filter]
-    end
-
-    it 'does not notify' do
-      expect(configuration).not_to receive(:notify)
-      compile [doc], receiver, [filter]
-    end
-  end
-
-  context 'dry run' do
-    let(:configuration) { double(dry_run?: true, notify: nil) }
-
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario do
-            step 'a passing step'
-          end
-        end
-      end
-    end
-
-    it 'activates each step with a skipping action' do
-      expect(receiver).to receive(:test_case) do |test_case|
-        expect(test_case.test_steps[0].execute).to be_skipped
-      end
-      compile [doc], receiver, [filter]
-    end
-
-    it 'notifies with a StepActivated event' do
-      expect(configuration).to receive(:notify) do |message, test_step, step_match|
-        expect(message).to eq :step_activated
-        expect(test_step.text).to eq 'a passing step'
-        expect(step_match).to eq step_match
-      end
-      compile [doc], receiver, [filter]
-    end
-  end
-
-  context 'undefined step in a dry run' do
-    let(:step_match_search) { Proc.new { [] } }
-    let(:configuration) { double(dry_run?: true, notify: nil) }
-
-    let(:doc) do
-      gherkin do
-        feature do
-          scenario do
-            step 'an undefined step'
-          end
-        end
-      end
-    end
-
-    it 'does not activate the step' do
-      expect(receiver).to receive(:test_case) do |test_case|
-        expect(test_case.test_steps[0].execute).to be_undefined
-      end
-      compile [doc], receiver, [filter]
-    end
-
-    it 'does not notify' do
-      expect(configuration).not_to receive(:notify)
-      compile [doc], receiver, [filter]
-    end
-  end
-
-end

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