cucumber 2.0.0.rc.4 → 4.0.0.rc.2

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

data/spec/spec_helper.rb

@@ -1,32 +0,0 @@
-ENV['CUCUMBER_COLORS'] = nil
-$:.unshift(File.dirname(__FILE__))
-
-# For Travis....
-if defined? Encoding
-  Encoding.default_external = 'utf-8'
-  Encoding.default_internal = 'utf-8'
-end
-
-load File.expand_path(File.dirname(__FILE__) + '/../spec/simplecov_setup.rb')
-
-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