cucumber 2.1.0 → 2.2.0

data/lib/cucumber/wire_support/wire_step_definition.rb

@@ -1,21 +0,0 @@
-require 'cucumber/core/ast/location'
-
-module Cucumber
-  module WireSupport
-    class WireStepDefinition
-      attr_reader :regexp_source, :location
-
-      def initialize(connection, data)
-        @connection = connection
-        @id              = data['id']
-        @regexp_source   = data['regexp'] || "Unknown"
-        @location = data['source'] ? Cucumber::Core::Ast::Location.from_file_colon_line(data['source']) : Cucumber::Core::Ast::Location.new("Unknown")
-      end
-
-      def invoke(args)
-        @connection.invoke(@id, args)
-      end
-
-    end
-  end
-end

data/spec/cucumber/events/bus_spec.rb

@@ -1,94 +0,0 @@
-require "cucumber/events/bus"
-
-module Cucumber
-  module Events
-    class TestEvent
-    end
-
-    class AnotherTestEvent
-    end
-
-    describe Bus do
-      let(:bus) { Bus.new(Cucumber::Events) }
-      let(:test_event) { TestEvent.new }
-      let(:another_test_event) { AnotherTestEvent.new }
-
-      it "calls subscriber with event payload" do
-        received_payload = nil
-        bus.register(TestEvent) do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      end
-
-      it "does not call subscribers for other events" do
-        handler_called = false
-        bus.register(TestEvent) do |event|
-          handler_called = true
-        end
-
-        bus.notify another_test_event
-
-        expect(handler_called).to eq(false)
-      end
-
-      it "broadcasts to multiple subscribers" do
-        received_events = []
-        bus.register(TestEvent) do |event|
-          received_events << event
-        end
-        bus.register(TestEvent) do |event|
-          received_events << event
-        end
-
-        bus.notify test_event
-
-        expect(received_events.length).to eq 2
-        expect(received_events).to all eq test_event
-      end
-
-      it "allows subscription by string" do
-        received_payload = nil
-        bus.register('Cucumber::Events::TestEvent') do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      end
-
-      it "allows subscription by symbol (for events in the Cucumber::Events namespace)" do
-        received_payload = nil
-        bus.register(:test_event) do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      end
-
-      it "allows handlers that are objects with a `call` method" do
-        class MyHandler
-          attr_reader :received_payload
-
-          def call(event)
-            @received_payload = event
-          end
-        end
-
-        handler = MyHandler.new
-        bus.register(TestEvent, handler)
-
-        bus.notify test_event
-
-        expect(handler.received_payload).to eq test_event
-      end
-
-    end
-  end
-end

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'cucumber/rb_support/regexp_argument_matcher'
-
-module Cucumber
-  module RbSupport
-    describe RegexpArgumentMatcher do
-      include RSpec::WorkInProgress
-
-      it "creates 2 arguments" do
-        arguments = RegexpArgumentMatcher.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 = RegexpArgumentMatcher.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
-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