cucumber 3.0.0 → 3.1.0

data/spec/cucumber/project_initializer_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'tmpdir'
-
-module Cucumber
-  describe ProjectInitializer, :isolated_home => true do
-    let(:command_line_config) { ProjectInitializer.new }
-
-    before do
-      allow(command_line_config).to receive(:puts)
-    end
-
-    context 'no files created' do
-      around(:example) do |example|
-
-        dir = Dir.mktmpdir
-        original_dir = Dir.pwd
-        begin
-          FileUtils.cd dir
-          example.call
-        ensure
-          FileUtils.cd original_dir
-          FileUtils.rm_rf dir
-        end
-      end
-
-      it 'should create features directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features$)
-        command_line_config.run
-      end
-
-      it 'should create step_definitions directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/step_definitions$)
-        command_line_config.run
-      end
-
-      it 'should create support directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support$)
-        command_line_config.run
-      end
-
-      it 'should create env.rb directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support/env.rb$)
-        command_line_config.run
-      end
-
-    end
-
-    context 'files created' do
-      around(:example) do |example|
-        dir = Dir.mktmpdir
-        FileUtils.mkdir_p "#{dir}/features"
-        FileUtils.mkdir_p "#{dir}/features/step_definitions"
-        FileUtils.mkdir_p "#{dir}/features/support"
-        FileUtils.touch "#{dir}/features/support/env.rb"
-        original_dir = Dir.pwd
-        begin
-          FileUtils.cd dir
-          example.call
-        ensure
-          FileUtils.cd original_dir
-          FileUtils.rm_rf dir
-        end
-      end
-
-      it 'should not create features directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features$)
-        command_line_config.run
-      end
-
-      it 'should not create step_definitions directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/step_definitions$)
-        command_line_config.run
-      end
-
-      it 'should not create support directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support$)
-        command_line_config.run
-      end
-
-      it 'should not create env.rb directory' do
-        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support/env.rb$)
-        command_line_config.run
-      end
-
-    end
-  end
-end

data/spec/cucumber/rake/forked_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/rake/task'
-require 'rake'
-
-module Cucumber
-  module Rake
-    describe Task::ForkedCucumberRunner do
-      let(:libs) { ['lib'] }
-      let(:binary) { Cucumber::BINARY }
-      let(:cucumber_opts) { ['--cuke-option'] }
-      let(:feature_files) { ['./some.feature'] }
-
-      context 'when running with bundler' do
-        let(:bundler) { true }
-
-        subject { Task::ForkedCucumberRunner.new(
-            libs, binary, cucumber_opts, bundler, feature_files) }
-
-        it 'does use bundler if bundler is set to true' do
-          expect(subject.use_bundler).to be true
-        end
-
-        it 'uses bundle exec to find cucumber and libraries' do
-          expect(subject.cmd).to eq [
-              Cucumber::RUBY_BINARY,
-              '-S',
-              'bundle',
-              'exec',
-              'cucumber',
-              '--cuke-option'
-            ] + feature_files
-        end
-      end
-
-      context 'when running without bundler' do
-        let(:bundler) { false }
-
-        subject { Task::ForkedCucumberRunner.new(
-            libs, binary, cucumber_opts, bundler, feature_files) }
-
-        it 'does not use bundler if bundler is set to false' do
-          expect(subject.use_bundler).to be false
-        end
-
-        it 'uses well known cucumber location and specified libraries' do
-          expect(subject.cmd).to eq [
-              Cucumber::RUBY_BINARY,
-              '-I',
-              '"lib"',
-              "\"#{Cucumber::BINARY}\"",
-              '--cuke-option'
-            ] + feature_files
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/rake/task_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/rake/task'
-require 'rake'
-
-module Cucumber
-  module Rake
-    describe Task do
-
-      describe '#cucumber_opts' do
-        before { subject.cucumber_opts = opts }
-
-        context 'when set via array' do
-          let(:opts) { %w[ foo bar ] }
-          it { expect(subject.cucumber_opts).to be opts }
-        end
-
-        context 'when set via space-delimited string' do
-          let(:opts) { 'foo bar' }
-          it { expect(subject.cucumber_opts).to eq %w[ foo bar ] }
-        end
-      end
-
-      describe '#cucumber_opts_with_profile' do
-        before do
-          subject.cucumber_opts = opts
-          subject.profile = profile
-        end
-
-        context 'with cucumber_opts' do
-          let(:opts) { %w[ foo bar ] }
-
-          context 'without profile' do
-            let(:profile) { nil }
-
-            it 'should return just cucumber_opts' do
-              expect(subject.cucumber_opts_with_profile).to be opts
-            end
-          end
-
-          context 'with profile' do
-            let(:profile) { 'fancy' }
-
-            it 'should combine opts and profile into an array, prepending --profile option' do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ foo bar --profile fancy ]
-            end
-          end
-
-          context 'with multiple profiles' do
-            let(:profile) { %w[ fancy pants ] }
-
-            it 'should combine opts and each profile into an array, prepending --profile option' do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ foo bar --profile fancy --profile pants ]
-            end
-          end
-        end
-
-        context 'without cucumber_opts' do
-          let(:opts) { nil }
-
-          context 'without profile' do
-            let(:profile) { nil }
-
-            it { expect(subject.cucumber_opts_with_profile).to eq [] }
-          end
-
-          context 'with profile' do
-            let(:profile) { 'fancy' }
-
-            it 'should combine opts and profile into an array, prepending --profile option' do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ --profile fancy ]
-            end
-          end
-
-          context 'with multiple profiles' do
-            let(:profile) { %w[ fancy pants ] }
-
-            it 'should combine opts and each profile into an array, prepending --profile option' do
-              expect(subject.cucumber_opts_with_profile).to eq %w[ --profile fancy --profile pants ]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/running_test_case_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/running_test_case'
-require 'cucumber/core'
-require 'cucumber/core/gherkin/writer'
-
-module Cucumber
-  describe RunningTestCase do
-    include Core
-    include Core::Gherkin::Writer
-
-    attr_accessor :wrapped_test_case, :core_test_case
-
-    let(:result) { double(:result, to_sym: :status_symbol) }
-
-    before do
-      receiver = double.as_null_object
-      allow(receiver).to receive(:test_case) { |core_test_case|
-        self.core_test_case = core_test_case
-        self.wrapped_test_case = RunningTestCase.new(core_test_case).with_result(result)
-      }
-      compile [gherkin_doc], receiver
-    end
-
-    context 'for a regular scenario' do
-      let(:gherkin_doc) do
-        gherkin do
-          feature 'feature name' do
-            scenario 'scenario name' do
-              step 'passing'
-            end
-          end
-        end
-      end
-
-      it 'sets the scenario name correctly' do
-        expect(wrapped_test_case.name).to eq 'scenario name'
-      end
-
-      it 'sets the feature name correctly' do
-        expect(wrapped_test_case.feature.name).to eq 'feature name'
-      end
-
-      it 'exposes properties of the test_case' do
-        expect(wrapped_test_case.location).to eq core_test_case.location
-        expect(wrapped_test_case.source).to eq core_test_case.source
-        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
-      end
-
-      it 'exposes properties of the result' do
-        expect(wrapped_test_case.status).to eq result.to_sym
-      end
-    end
-
-    context 'for a failed scenario' do
-      let(:gherkin_doc) do
-        gherkin do
-          feature 'feature name' do
-            scenario 'scenario name' do
-              step 'failed'
-            end
-          end
-        end
-      end
-
-      let(:exception) { StandardError.new }
-
-      before do
-        self.wrapped_test_case = self.wrapped_test_case.with_result(Core::Test::Result::Failed.new(0, exception))
-      end
-
-      it 'is failed?' do
-        expect(wrapped_test_case.failed?).to be_truthy
-      end
-
-      it 'exposes the exception' do
-        expect(wrapped_test_case.exception).to eq exception
-      end
-    end
-
-    context 'for a passing scenario' do
-      let(:gherkin_doc) do
-        gherkin do
-          feature 'feature name' do
-            scenario 'scenario name' do
-              step 'passing'
-            end
-          end
-        end
-      end
-
-      before do
-        self.wrapped_test_case = self.wrapped_test_case.with_result(Core::Test::Result::Passed.new(0))
-      end
-
-      it 'is not failed?' do
-        expect(wrapped_test_case.failed?).to be_falsey
-      end
-
-      it '#exception is nil' do
-        expect(wrapped_test_case.exception).to be_nil
-      end
-    end
-
-    context 'for a scenario outline' do
-      let(:gherkin_doc) do
-        gherkin do
-          feature 'feature name' do
-            scenario_outline 'scenario outline name' do
-              step 'passing with <arg1> <arg2>'
-
-              examples 'examples name' do
-                row 'arg1', 'arg2'
-                row 'a', 'b'
-              end
-            end
-          end
-        end
-      end
-
-      it "sets the test case's name correctly" do
-        expect(wrapped_test_case.name).to eq 'scenario outline name, examples name (#1)'
-      end
-
-      it 'sets the feature name correctly' do
-        expect(wrapped_test_case.feature.name).to eq 'feature name'
-      end
-
-      it 'exposes properties of the test_case' do
-        expect(wrapped_test_case.location).to eq core_test_case.location
-        expect(wrapped_test_case.source).to eq core_test_case.source
-        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
-      end
-
-      it 'exposes the examples table row cell values' do
-        expect(wrapped_test_case.cell_values).to eq %w(a b)
-      end
-
-    end
-  end
-end

data/spec/cucumber/runtime/for_programming_languages_spec.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Cucumber
-  describe Runtime::ForProgrammingLanguages do
-    it 'should probably be inlined'
-  end
-end

data/spec/cucumber/runtime/support_code_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Cucumber
-  describe Runtime::SupportCode do
-    let(:user_interface) { double('user interface') }
-    subject { Runtime::SupportCode.new(user_interface, configuration) }
-    let(:configuration) { Configuration.new(options) }
-    let(:options) { {}}
-    let(:dsl) do
-      @rb = subject.ruby
-      Object.new.extend(RbSupport::RbDsl)
-    end
-
-
-  end
-end

data/spec/cucumber/runtime_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-module Cucumber
-  describe Runtime do
-    subject { Runtime.new(options) }
-    let(:options) { {} }
-
-    describe '#features_paths' do
-      let(:options) { {:paths => ['foo/bar/baz.feature', 'foo/bar/features/baz.feature', 'other_features'] } }
-
-      it 'returns the value from configuration.paths' do
-        expect(subject.features_paths).to eq options[:paths]
-      end
-    end
-
-    it '#doc_string' do
-      expect(subject.doc_string('Text')).to eq 'Text'
-    end
-  end
-end

data/spec/cucumber/sell_cucumbers.feature

@@ -1,19 +0,0 @@
-Feature: Sell cucumbers
-  As a cucumber farmer
-  I want to sell cucumbers
-  So that I buy meat
-
-  Scenario: Sell a dozen
-    Given there are 5 cucumbers
-    When I sell 12 cucumbers
-    Then I should owe 7 cucumbers
-
-  Scenario: Sell twenty
-    Given there are 5 cucumbers
-    When I sell 20 cucumbers
-    Then I should owe 15 cucumbers
-
-  Scenario: Sell fifty
-    Given there are 5 cucumbers
-    When I sell 50 cucumbers
-    Then I should owe 45 cucumbers

data/spec/cucumber/step_argument_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/step_argument'
-
-module Cucumber
-  describe StepArgument do
-    it 'creates 2 arguments' do
-      arguments = StepArgument.arguments_from(/I (\w+) (\w+)/, 'I like fish')
-
-      expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [['like', 2], ['fish', 7]]
-    end
-
-    it 'creates 2 arguments when first group is optional' do
-      arguments = StepArgument.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
-
-      expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [[nil, nil], ['Login failed.', 21]]
-    end
-  end
-end

data/spec/cucumber/step_match_search_spec.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/step_match_search'
-require 'cucumber/glue/dsl'
-require 'cucumber/glue/registry_and_more'
-require 'cucumber/configuration'
-
-module Cucumber
-  describe StepMatchSearch do
-
-    let(:search) { StepMatchSearch.new(registry.method(:step_matches), configuration) }
-    let(:registry) { Glue::RegistryAndMore.new(runtime, configuration) }
-    let(:runtime) do
-      # TODO: break out step definitions collection from Glue::RegistryAndMore so we don't need this
-      :unused
-    end
-    let(:configuration) { Configuration.new(options) }
-    let(:options) { {} }
-    let(:dsl) do
-      # TODO: stop relying on implicit global state
-      registry
-      Object.new.extend(Glue::Dsl)
-    end
-
-    context 'caching' do
-      it 'caches step match results' do
-        dsl.Given(/it (.*) in (.*)/) { |what, month| }
-
-        step_match = search.call('it snows in april').first
-
-        expect(registry).not_to receive(:step_matches)
-        second_step_match = search.call('it snows in april').first
-
-        expect(step_match).to equal(second_step_match)
-      end
-    end
-
-    describe 'resolving step defintion matches' do
-
-      it 'raises Ambiguous error with guess hint when multiple step definitions match' do
-        expected_error = %{Ambiguous match of "Three blind mice":
-
-spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three (.*) mice/'
-spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three blind (.*)/'
-
-You can run again with --guess to make Cucumber be more smart about it
-}
-        dsl.Given(/Three (.*) mice/) {|disability|}
-        dsl.Given(/Three blind (.*)/) {|animal|}
-
-        expect(-> {
-          search.call('Three blind mice').first
-        }).to raise_error(Ambiguous, /#{expected_error}/)
-      end
-
-      describe 'when --guess is used' do
-        let(:options) { {:guess => true} }
-
-        it 'does not show --guess hint' do
-        expected_error = %{Ambiguous match of "Three cute mice":
-
-spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three (.*) mice/'
-spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three cute (.*)/'
-
-}
-          dsl.Given(/Three (.*) mice/) {|disability|}
-          dsl.Given(/Three cute (.*)/) {|animal|}
-
-          expect(-> {
-            search.call('Three cute mice').first
-          }).to raise_error(Ambiguous, /#{expected_error}/)
-        end
-
-        it 'does not raise Ambiguous error when multiple step definitions match' do
-          dsl.Given(/Three (.*) mice/) {|disability|}
-          dsl.Given(/Three (.*)/) {|animal|}
-
-          expect(-> {
-            search.call('Three blind mice').first
-          }).not_to raise_error
-        end
-
-        it 'picks right step definition when an equal number of capture groups' do
-          right  = dsl.Given(/Three (.*) mice/) {|disability|}
-          _wrong = dsl.Given(/Three (.*)/) {|animal|}
-
-          expect(search.call('Three blind mice').first.step_definition).to eq right
-        end
-
-        it 'picks right step definition when an unequal number of capture groups' do
-          right  = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-          _wrong = dsl.Given(/Three (.*)/) {|animal|}
-
-          expect(search.call('Three blind mice ran far').first.step_definition).to eq right
-        end
-
-        it 'picks most specific step definition when an unequal number of capture groups' do
-          _general      = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-          _specific     = dsl.Given(/Three blind mice ran far/) do; end
-          more_specific = dsl.Given(/^Three blind mice ran far$/) do; end
-
-          expect(search.call('Three blind mice ran far').first.step_definition).to eq more_specific
-        end
-      end
-
-      # TODO: remove this - it's ... redundant
-      # http://railsforum.com/viewtopic.php?pid=93881
-      it "does not raise Redundant unless it's really redundant" do
-        dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
-        dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
-      end
-    end
-  end
-end

data/spec/cucumber/step_match_spec.rb

@@ -1,86 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/glue/step_definition'
-require 'cucumber/glue/registry_and_more'
-
-module Cucumber
-  describe StepMatch do
-    WORD = '[[:word:]]'
-
-    before do
-      @registry = Glue::RegistryAndMore.new(nil, Configuration.new)
-    end
-
-    def stepdef(string_or_regexp)
-      Glue::StepDefinition.new(@registry, string_or_regexp, lambda{}, {})
-    end
-
-    def step_match(regexp, name)
-      stepdef = stepdef(regexp)
-      StepMatch.new(stepdef, name, stepdef.arguments_from(name))
-    end
-
-    it 'formats step names' do
-      m = step_match(/it (.*) in (.*)/, 'it snows in april')
-      format = m.format_args('[%s]')
-      expect(format).to eq 'it [snows] in [april]'
-    end
-
-    it 'formats one group when we use Unicode' do
-      m = step_match(/I (#{WORD}+) ok/, "I æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ ok")
-
-      expect(m.format_args('<span>%s</span>')).to eq "I <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> ok"
-    end
-
-    it 'formats several groups when we use Unicode' do
-      m = step_match(/I (#{WORD}+) (#{WORD}+) (#{WORD}+) this (#{WORD}+)/, "I ate æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ egg this morning")
-
-      expect(m.format_args('<span>%s</span>')).to eq "I <span>ate</span> <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> <span>egg</span> this <span>morning</span>"
-    end
-
-    it 'deals with Unicode both inside and outside arguments' do
-      expect("Jæ vø ålsker døtte løndet").to match(/Jæ (.+) ålsker (.+) løndet/)
-
-      m = step_match(/Jæ (#{WORD}+) ålsker (#{WORD}+) løndet/, "Jæ vø ålsker døtte løndet")
-
-      expect(m.format_args('<span>%s</span>')).to eq "Jæ <span>vø</span> ålsker <span>døtte</span> løndet"
-    end
-
-    it 'formats groups with format string' do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I ate 1 egg this morning')
-
-      expect(m.format_args('<span>%s</span>')).to eq 'I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>'
-    end
-
-    it 'formats groups with format string when there are dupes' do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I bob 1 bo this bobs')
-
-      expect(m.format_args('<span>%s</span>')).to eq 'I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>'
-    end
-
-    it 'formats groups with block' do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I ate 1 egg this morning')
-
-      expect(m.format_args(&lambda{|m| "<span>#{m}</span>"})).to eq 'I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>'
-    end
-
-    it 'formats groups with proc object' do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I ate 1 egg this morning')
-
-      expect(m.format_args(lambda{|m| "<span>#{m}</span>"})).to eq 'I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>'
-    end
-
-    it 'formats groups even when first group is optional and not matched' do
-      m = step_match(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
-
-      expect(m.format_args('<span>%s</span>')).to eq "I should be flashed '<span>Login failed.</span>'"
-    end
-
-    it 'formats embedded groups' do
-      m = step_match(/running( (\d+) times)? (\d+) meters/, 'running 5 times 10 meters')
-
-      expect(m.format_args('<span>%s</span>')).to eq 'running<span> 5 times</span> <span>10</span> meters'
-    end
-  end
-end