cucumber 3.0.1 → 3.2.0

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'yaml'
-
-module Cucumber
-  module Cli
-    describe ProfileLoader do
-      def given_cucumber_yml_defined_as(hash_or_string)
-        allow(Dir).to receive(:glob).with('{,.config/,config/}cucumber{.yml,.yaml}') { ['cucumber.yml'] }
-        allow(File).to receive(:exist?) { true }
-
-        cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
-
-        allow(IO).to receive(:read).with('cucumber.yml') { cucumber_yml }
-      end
-
-      def loader
-        ProfileLoader.new
-      end
-
-      it 'treats backslashes as literals in rerun.txt when on Windows (JRuby or MRI)' do
-        given_cucumber_yml_defined_as('default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22')
-        if(Cucumber::WINDOWS)
-          expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22']
-        else
-          expect(loader.args_from('default')).to eq ['--format','pretty','featuressync_imap_mailbox.feature:16:22']
-        end
-      end
-
-      it 'treats forward slashes as literals' do
-        given_cucumber_yml_defined_as('default' => '--format "ugly" features/sync_imap_mailbox.feature:16:22')
-
-        expect(loader.args_from('default')).to eq ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
-      end
-
-      it 'treats percent sign as ERB code block after YAML directive' do
-        yml = <<-HERE
----
-% x = '--format "pretty" features/sync_imap_mailbox.feature:16:22'
-default: <%= x %>
-        HERE
-        given_cucumber_yml_defined_as yml
-        expect(loader.args_from('default')).to eq ['--format','pretty','features/sync_imap_mailbox.feature:16:22']
-      end
-
-      it 'correctly parses a profile that uses tag expressions (with double quotes)' do
-        given_cucumber_yml_defined_as('default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22 --tags "not @jruby"')
-        if(Cucumber::WINDOWS)
-          expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22','--tags','not @jruby']
-        else
-          expect(loader.args_from('default')).to eq ['--format','pretty','featuressync_imap_mailbox.feature:16:22','--tags','not @jruby']
-        end
-      end
-
-      it 'correctly parses a profile that uses tag expressions (with single quotes)' do
-        given_cucumber_yml_defined_as('default' => "--format 'pretty' features\\sync_imap_mailbox.feature:16:22 --tags 'not @jruby'")
-        if(Cucumber::WINDOWS)
-          expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22','--tags','not @jruby']
-        else
-          expect(loader.args_from('default')).to eq ['--format','pretty','featuressync_imap_mailbox.feature:16:22','--tags','not @jruby']
-        end
-      end
-
-    end
-  end
-end

data/spec/cucumber/cli/rerun_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Cucumber
-  module Cli
-    describe RerunFile do
-
-      let(:rerun_file) { RerunFile.new('@rerun.txt') }
-
-      it 'expects rerun files to have a leading @' do
-        allow(File).to receive(:file?) { true }
-        expect(RerunFile.can_read?('rerun.txt')).to eq false
-        expect(RerunFile.can_read?('@rerun.txt')).to eq true
-      end
-
-      it 'does not treat directories as rerun files' do
-        allow(File).to receive(:file?) { false }
-        expect(RerunFile.can_read?('@rerun.txt')).to eq false
-      end
-
-      it 'removes leading @ character from filename' do
-        expect(rerun_file.path).to eq 'rerun.txt'
-      end
-
-      context 'rerun file containing single feature' do
-        before(:each) do
-          allow(IO).to receive(:read).and_return('cucumber.feature')
-        end
-
-        it 'produces an array containing a single feature file path' do
-          expect(rerun_file.features).to eq %w(cucumber.feature)
-        end
-      end
-
-      context 'contains multiple features on multiple lines' do
-        before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature\nfoo.feature")
-        end
-
-        it 'produces an array containing multiple feature file paths' do
-          expect(rerun_file.features).to eq %w(cucumber.feature foo.feature)
-        end
-      end
-
-      context 'contains multiple features on same line' do
-        before(:each) do
-          allow(IO).to receive(:read).and_return('cucumber.feature foo.feature')
-        end
-
-        it 'produces an array containing multiple feature file paths' do
-          expect(rerun_file.features).to eq %w(cucumber.feature foo.feature)
-        end
-      end
-
-      context 'contains multiple scenarios on same line' do
-        before(:each) do
-          allow(IO).to receive(:read).and_return('cucumber.feature:8 foo.feature:8:16')
-        end
-
-        it 'produces an array containing multiple feature file paths with scenario lines' do
-          expect(rerun_file.features).to eq %w(cucumber.feature:8 foo.feature:8:16)
-        end
-      end
-
-      context 'contains features with spaces in file names' do
-        before(:each) do
-          allow(IO).to receive(:read).and_return('cucumber test.feature:8 foo.feature:8:16')
-        end
-
-        it 'produces an array containing multiple feature file paths with scenario lines' do
-          expect(rerun_file.features).to eq ['cucumber test.feature:8', 'foo.feature:8:16']
-        end
-      end
-
-      context 'contains multiple scenarios without spaces between them' do
-        before(:each) do
-          allow(IO).to receive(:read).and_return('cucumber test.feature:8foo.feature:8:16')
-        end
-
-        it 'produces an array containing multiple feature file paths with scenario lines' do
-          expect(rerun_file.features).to eq ['cucumber test.feature:8', 'foo.feature:8:16']
-        end
-      end
-    end
-  end
-end

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