cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/spec/cucumber/runtime_spec.rb

@@ -1,46 +0,0 @@
-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
-
-    describe "#configure" do
-      let(:support_code)      { double(Runtime::SupportCode).as_null_object }
-      let(:new_configuration) { double('New configuration')}
-
-      before(:each) do
-        allow(Runtime::SupportCode).to receive(:new) { support_code }
-      end
-
-      it "tells the support_code about the new configuration" do
-        expect(support_code).to receive(:configure).with(new_configuration)
-        subject.configure(new_configuration)
-      end
-
-      it "replaces the existing configuration" do
-        # not really sure how to test this. Maybe we should just expose
-        # Runtime#configuration with an attr_reader?
-        some_new_paths = ['foo/bar', 'baz']
-
-        allow(new_configuration).to receive(:paths) { some_new_paths }
-
-        subject.configure(new_configuration)
-
-        expect(subject.features_paths).to eq some_new_paths
-      end
-
-      it '#doc_string' do
-        expect(subject.doc_string('Text')).to eq 'Text'
-      end
-    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_match_spec.rb

@@ -1,79 +0,0 @@
-# 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)
-    end
-
-    def stepdef(regexp)
-      RbSupport::RbStepDefinition.new(@rb_language, regexp, lambda{}, {})
-    end
-
-    def step_match(regexp, name)
-      stepdef = stepdef(regexp)
-      StepMatch.new(stepdef, name, nil, stepdef.arguments_from(name))
-    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/wire_support/configuration_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'cucumber/wire_support/wire_language'
-require 'tempfile'
-
-module Cucumber
-  module WireSupport
-    describe Configuration do
-      let(:wire_file) { Tempfile.new('wire') }
-      let(:config) { Configuration.from_file(wire_file.path) }
-
-      def write_wire_file(contents)
-        wire_file << contents
-        wire_file.close
-      end
-
-      it "reads the hostname / port from the file" do
-        write_wire_file %q{
-          host: localhost
-          port: 54321
-        }
-
-        expect(config.host).to eq 'localhost'
-        expect(config.port).to eq 54321
-      end
-
-      it "reads the timeout for a specific message" do
-        write_wire_file %q{
-          host: localhost
-          port: 54321
-          timeout:
-            invoke: 99
-        }
-
-        expect(config.timeout('invoke')).to eq 99
-      end
-
-      it "reads the timeout for a connect message" do
-        write_wire_file %q{
-          host: localhost
-          port: 54321
-          timeout:
-            connect: 99
-        }
-
-        expect(config.timeout('connect')).to eq 99
-      end
-
-      describe "a wire file with no timeouts specified" do
-        before(:each) do
-          write_wire_file %q{
-            host: localhost
-            port: 54321
-          }
-        end
-
-        %w(invoke begin_scenario end_scenario).each do |message|
-          it "sets the default timeout for '#{message}' to 120 seconds" do
-            expect(config.timeout(message)).to eq 120
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/wire_support/connection_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'cucumber/wire_support/wire_language'
-
-module Cucumber
-  module WireSupport
-    describe Connection do
-      class TestConnection < Connection
-        attr_accessor :socket
-      end
-
-      class TestConfiguration
-        attr_reader :custom_timeout
-
-        def initialize
-          @custom_timeout = {}
-        end
-
-        def timeout(message = nil)
-          return :default_timeout if message.nil?
-          @custom_timeout[message] || Configuration::DEFAULT_TIMEOUTS.fetch(message)
-        end
-
-        def host
-          'localhost'
-        end
-
-        def port
-          '3902'
-        end
-      end
-
-      before(:each) do
-        @config = TestConfiguration.new
-        @connection = TestConnection.new(@config)
-        @connection.socket = @socket = double('socket').as_null_object
-        @response = %q{["response"]}
-      end
-
-      it "re-raises a timeout error" do
-        allow(Timeout).to receive(:timeout).and_raise(Timeout::Error.new(''))
-        expect(-> { @connection.call_remote(nil, :foo, []) }).to raise_error(Timeout::Error)
-      end
-
-      it "ignores timeout errors when configured to do so" do
-        @config.custom_timeout[:foo] = :never
-
-        allow(@socket).to receive(:gets) { @response }
-
-        handler = double(:handle_response => :response)
-
-        expect(@connection.call_remote(handler, :foo, [])).to eq :response
-      end
-
-      it "raises an exception on remote connection closed" do
-        @config.custom_timeout[:foo] = :never
-
-        allow(@socket).to receive(:gets)
-        expect(-> {
-          @connection.call_remote(nil, :foo, [])
-        }).to raise_error(WireException, 'Remote Socket with localhost:3902 closed.')
-      end
-    end
-  end
-end

data/spec/cucumber/wire_support/wire_exception_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'cucumber/wire_support/wire_language'
-
-module Cucumber
-  module WireSupport
-    describe WireException do
-      before(:each) do
-        @config = Configuration.new('host' => 'localhost', 'port' => 54321)
-      end
-
-      def exception
-        WireException.new(@data, @config)
-      end
-
-      describe "with just a message" do
-        before(:each) do
-          @data = {'message' => 'foo'}
-        end
-
-        it "#to_s as expecteds" do
-          expect(exception.to_s).to eq "foo"
-        end
-      end
-
-      describe "with a message and an exception" do
-        before(:each) do
-          @data = {'message' => 'foo', 'exception' => 'Bar'}
-        end
-
-        it "#to_s as expecteds" do
-          expect(exception.to_s).to eq "foo"
-        end
-
-        it "#class.to_s returns the name of the exception" do
-          expect(exception.class.to_s).to eq 'Bar from localhost:54321'
-        end
-      end
-
-      describe "with a custom backtrace" do
-        before(:each) do
-          @data = {'message' => 'foo', 'backtrace' => ['foo', 'bar', 'baz']}
-        end
-
-        it "#backrace returns the custom backtrace" do
-          expect(exception.backtrace).to eq ['foo', 'bar', 'baz']
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/wire_support/wire_language_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'cucumber/wire_support/wire_language'
-
-module Cucumber
-  module WireSupport
-    describe WireLanguage do
-      def stub_wire_file!(filename, config)
-        allow(Configuration).to receive(:from_file).with(filename) { config }
-      end
-
-      describe "#load_code_file" do
-        before(:each) do
-          stub_wire_file! 'foo.wire', :config
-        end
-
-        it "creates a RemoteSteps object" do
-          expect(Connection).to receive(:new).with(:config)
-
-          WireLanguage.new.load_code_file('foo.wire')
-        end
-      end
-
-      describe "#step_matches" do
-        def stub_remote_steps!(config, attributes)
-          expect(Connection).to receive(:new).with(config) { double('remote_steps', attributes) }
-        end
-
-        before(:each) do
-          stub_wire_file! 'one.wire', :config_one
-          stub_wire_file! 'two.wire', :config_two
-        end
-
-        it "returns the matches from each of the RemoteSteps" do
-          stub_remote_steps! :config_one, :step_matches => [:a, :b]
-          stub_remote_steps! :config_two, :step_matches => [:c]
-
-          wire_language = WireLanguage.new
-          wire_language.load_code_file('one.wire')
-          wire_language.load_code_file('two.wire')
-
-          expect(wire_language.step_matches('','')).to eq [:a, :b, :c]
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/wire_support/wire_packet_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'cucumber/wire_support/wire_language'
-
-module Cucumber
-  module WireSupport
-    describe WirePacket do
-      describe "#to_json" do
-        it "converts params to a JSON hash" do
-          packet = WirePacket.new('test_message', :foo => :bar)
-
-          expect(packet.to_json).to eq "[\"test_message\",{\"foo\":\"bar\"}]"
-        end
-
-        it "does not pass blank params" do
-          packet = WirePacket.new('test_message')
-
-          expect(packet.to_json).to eq "[\"test_message\"]"
-        end
-      end
-
-      describe ".parse" do
-        it "understands a raw packet containing null parameters" do
-          packet = WirePacket.parse("[\"test_message\",null]")
-
-          expect(packet.message).to eq 'test_message'
-          expect(packet.params).to be_nil
-        end
-
-        it "understands a raw packet containing no parameters" do
-          packet = WirePacket.parse("[\"test_message\"]")
-
-          expect(packet.message).to eq 'test_message'
-          expect(packet.params).to be_nil
-        end
-
-        it "understands a raw packet containging parameters data" do
-          packet = WirePacket.parse("[\"test_message\",{\"foo\":\"bar\"}]")
-
-          expect(packet.params['foo']).to eq 'bar'
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/world/pending_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'cucumber/rb_support/rb_language'
-
-module Cucumber
-  describe 'Pending' do
-    before(:each) do
-      l = RbSupport::RbLanguage.new(Runtime.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