cucumber 3.0.0.pre.2 → 4.0.0.rc.5

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

data/spec/cucumber/world/pending_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/glue/registry_and_more'
-require 'cucumber/configuration'
-
-module Cucumber
-  describe 'Pending' do
-    before(:each) do
-      registry = Glue::RegistryAndMore.new(Runtime.new, Configuration.new)
-      registry.begin_scenario(double('scenario').as_null_object)
-      @world = registry.current_world
-    end
-
-    it 'raises a Pending if no block is supplied' do
-      expect(-> {
-        @world.pending 'TODO'
-      }).to raise_error(Cucumber::Pending, /TODO/)
-    end
-
-    it 'raises a Pending if a supplied block fails as expected' do
-      expect(-> {
-        @world.pending 'TODO' do
-        raise 'oops'
-        end
-      }).to raise_error(Cucumber::Pending, /TODO/)
-    end
-
-    it 'raises a Pending if a supplied block fails as expected with a double' do
-      expect do
-        @world.pending 'TODO' do
-          m = double('thing')
-          expect(m).to receive(:foo)
-          RSpec::Mocks.verify
-        end
-      end.to raise_error(Cucumber::Pending, /TODO/)
-      # The teardown is needed so that the message expectation does not bubble up.
-      RSpec::Mocks.teardown
-    end
-
-    it 'raises a Pending if a supplied block starts working' do
-      expect(-> {
-        @world.pending 'TODO' do
-        # success!
-        end
-      }).to raise_error(Cucumber::Pending, /TODO/)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-ENV['CUCUMBER_COLORS'] = nil
-$:.unshift(File.dirname(__FILE__))
-
-# For Travis....
-require 'cucumber/encoding'
-
-require 'simplecov_setup'
-
-require 'pry'
-
-require 'cucumber'
-
-RSpec.configure do |c|
-  c.before do
-    ::Cucumber::Term::ANSIColor.coloring = true
-  end
-end
-
-module RSpec
-  module WorkInProgress
-    def pending_under(platforms, reason, &block)
-      if [platforms].flatten.map(&:to_s).include? RUBY_PLATFORM
-        pending "pending under #{platforms.inspect} because: #{reason}", &block
-      else
-        yield
-      end
-    end
-  end
-end

data/spec/support/standard_step_actions.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-# Filter that activates steps with obvious pass / fail behaviour
-class StandardStepActions < Cucumber::Core::Filter.new
-  def test_case(test_case)
-    test_steps = test_case.test_steps.map do |step|
-      case step.name
-      when /fail/
-        step.with_action { raise Failure }
-      when /pass/
-        step.with_action {}
-      else
-        step
-      end
-    end
-
-    test_case.with_steps(test_steps).describe_to(receiver)
-  end
-end
-