mobiusloop 0.1.2

data/spec/cucumber/runtime/for_programming_languages_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Cucumber
+  describe Runtime::ForProgrammingLanguages do
+
+    let(:user_interface)  { double('user interface') }
+    subject               { Runtime::SupportCode.new(user_interface) }
+    let(:runtime_facade)  { Runtime::ForProgrammingLanguages.new(subject, user_interface) }
+
+    describe "#doc_string" do
+
+      it 'defaults to a blank content-type' do
+        str = runtime_facade.doc_string('DOC')
+        expect(str).to be_kind_of(MultilineArgument::DocString)
+        expect(str.content_type).to eq('')
+      end
+
+      it 'can have a content type' do
+        str = runtime_facade.doc_string('DOC','ruby')
+        expect(str.content_type).to eq('ruby')
+      end
+
+    end
+
+    describe "#table" do
+
+      it 'produces Ast::Table by #table' do
+        expect(runtime_facade.table(%{
+      | account | description | amount |
+      | INT-100 | Taxi        | 114    |
+      | CUC-101 | Peeler      | 22     |
+        })).to be_kind_of(MultilineArgument::DataTable)
+      end
+    end
+  end
+end

data/spec/cucumber/runtime/support_code_spec.rb

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,122 @@
+require 'cucumber/step_match_search'
+require 'cucumber/rb_support/rb_dsl'
+require 'cucumber/rb_support/rb_language'
+require 'cucumber/configuration'
+
+module Cucumber
+  describe StepMatchSearch do
+
+    let(:search) { StepMatchSearch.new(rb_language.method(:step_matches), configuration) }
+    let(:rb_language) { RbSupport::RbLanguage.new(runtime, configuration) }
+    let(:runtime) do
+      # TODO: break out step definitions collection from RbLanguage 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
+      rb_language
+      Object.new.extend(RbSupport::RbDsl)
+    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(rb_language).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 "does not raise NoMethodError when guessing from multiple step definitions with nil fields" do
+          dsl.Given(/Three (.*) mice( cannot find food)?/) {|disability, is_disastrous|}
+          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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'cucumber/rb_support/rb_step_definition'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  describe StepMatch do
+    WORD = '[[:word:]]'
+
+    before do
+      @rb_language = RbSupport::RbLanguage.new(nil, Configuration.new)
+    end
+
+    def stepdef(regexp)
+      RbSupport::RbStepDefinition.new(@rb_language, 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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'cucumber/rb_support/rb_language'
+require 'cucumber/configuration'
+
+module Cucumber
+  describe 'Pending' do
+    before(:each) do
+      l = RbSupport::RbLanguage.new(Runtime.new, Configuration.new)
+      l.begin_rb_scenario(double('scenario').as_null_object)
+      @world = l.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/cucumber_spec.rb

@@ -0,0 +1,39 @@
+require 'cucumber'
+
+describe Cucumber do
+
+  # Implementation is backported from ruby 2.0 when cucumber is used on ruby 1.9.
+  # The tests will run on all implementations to ensure we have the same
+  # feature set.
+  describe 'Hash' do
+    it "converts nil to empty {}" do
+      expect(Cucumber::Hash(nil)).to eq({})
+    end
+
+    it "converts [] to {}" do
+      expect(Cucumber::Hash([])).to eq({})
+    end
+
+    it "converts a hash to an equivalent hash" do
+      original = {:a => 1, :b => 2}
+      expect(Cucumber::Hash(original)).to eq({a: 1, b: 2})
+    end
+
+    it "converts an object with a to_hash method" do
+      original = Object.new
+      def original.to_hash
+        {key: "value"}
+      end
+
+      expect(Cucumber::Hash(original)).to eq({key: "value"})
+    end
+
+    it "raises a TypeError for an object that does not have .to_hash" do
+      original = %w(cannot convert to hash)
+
+      expect { Cucumber::Hash(original) }.to raise_error TypeError
+    end
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,18 @@
+# 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
+