cucumber-wire 0.0.1

data/lib/cucumber/wire.rb

@@ -0,0 +1,5 @@
+require 'cucumber/wire/plugin'
+
+AfterConfiguration do |config|
+  Cucumber::Wire::Plugin.new(config).install
+end

data/lib/cucumber/wire/add_hooks_filter.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  module Wire
+    class AddHooksFilter < Core::Filter.new(:connections)
+      def test_case(test_case)
+        test_case.
+          with_steps([before_hook(test_case)] + test_case.test_steps + [after_hook(test_case)]).
+          describe_to receiver
+      end
+
+      def before_hook(test_case)
+        # TODO: is this dependency on Cucumber::Hooks OK? Feels a bit internal..
+        # TODO: how do we express the location of the hook? Should we create one hook per connection so we can use the host:port of the connection?
+        Cucumber::Hooks.before_hook(test_case.source, Core::Ast::Location.new('TODO:wire')) do
+          connections.begin_scenario(test_case)
+        end
+      end
+
+      def after_hook(test_case)
+        Cucumber::Hooks.after_hook(test_case.source, Core::Ast::Location.new('TODO:wire')) do
+          connections.end_scenario(test_case)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/wire/configuration.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+require 'erb'
+
+module Cucumber
+  module Wire
+    class Configuration
+      attr_reader :host, :port, :unix
+
+      def self.from_file(wire_file)
+        settings = YAML.load(ERB.new(File.read(wire_file)).result)
+        new(settings)
+      end
+
+      def initialize(args)
+        @host = args['host']
+        @port = args['port']
+        @unix = args['unix'] if RUBY_PLATFORM !~ /mingw|mswin/
+        @timeouts = DEFAULT_TIMEOUTS.merge(args['timeout'] || {})
+      end
+
+      def timeout(message = nil)
+        return @timeouts[message.to_s] || 3
+      end
+
+      def to_s
+        return @unix if @unix
+        "#{@host}:#{@port}"
+      end
+
+      DEFAULT_TIMEOUTS = {
+        'connect' => 11,
+        'invoke' => 120,
+        'begin_scenario' => 120,
+        'end_scenario' => 120
+      }
+    end
+  end
+end

data/lib/cucumber/wire/connection.rb

@@ -0,0 +1,63 @@
+require 'timeout'
+require 'cucumber/wire/protocol'
+require 'cucumber/wire/exception'
+require 'cucumber/wire/data_packet'
+
+module Cucumber
+  module Wire
+    class Connection
+      class ConnectionError < StandardError; end
+
+      include Wire::Protocol
+
+      def initialize(config)
+        @config = config
+      end
+
+      def call_remote(request_handler, message, params)
+        packet = DataPacket.new(message, params)
+
+        begin
+          send_data_to_socket(packet.to_json)
+          response = fetch_data_from_socket(@config.timeout(message))
+          response.handle_with(request_handler)
+        rescue Timeout::Error => e
+          backtrace = e.backtrace ; backtrace.shift # because Timeout puts some wierd stuff in there
+          raise Timeout::Error, "Timed out calling wire server with message '#{message}'", backtrace
+        end
+      end
+
+      def exception(params)
+        Wire::Exception.new(params, @config)
+      end
+
+      private
+
+      def send_data_to_socket(data)
+        Timeout.timeout(@config.timeout('connect')) { socket.puts(data) }
+      end
+
+      def fetch_data_from_socket(timeout)
+        raw_response =
+          if timeout == :never
+            socket.gets
+          else
+            Timeout.timeout(timeout) { socket.gets }
+          end
+        raise exception({'message' => "Remote Socket with #{@config.host}:#{@config.port} closed."}) if raw_response.nil?
+        DataPacket.parse(raw_response)
+      end
+
+      def socket
+        return @socket if @socket
+        if @config.unix
+          @socket = UNIXSocket.new(@config.unix)
+        else
+          @socket = TCPSocket.new(@config.host, @config.port)
+        end
+      rescue Errno::ECONNREFUSED => exception
+        raise(ConnectionError, "Unable to contact the wire server at #{@config}. Is it up?")
+      end
+    end
+  end
+end

data/lib/cucumber/wire/connections.rb

@@ -0,0 +1,50 @@
+require 'multi_json'
+require 'socket'
+require 'cucumber/wire/connection'
+require 'cucumber/wire/configuration'
+require 'cucumber/wire/data_packet'
+require 'cucumber/wire/exception'
+require 'cucumber/wire/step_definition'
+require 'cucumber/wire/snippet'
+require 'cucumber/configuration'
+require 'cucumber/step_match'
+
+module Cucumber
+  module Wire
+
+    class Connections
+      attr_reader :connections
+      private :connections
+
+      def initialize(connections, configuration)
+        raise ArgumentError unless connections
+        @connections = connections
+        @configuration = configuration
+      end
+
+      def find_match(test_step)
+        matches = step_matches(test_step.name)
+        return unless matches.any?
+        # TODO: handle ambiguous matches (push to cucumber?)
+        matches.first
+      end
+
+      def step_matches(step_name)
+        connections.map{ |c| c.step_matches(step_name)}.flatten
+      end
+
+      def begin_scenario(test_case)
+        connections.each { |c| c.begin_scenario(test_case) }
+      end
+
+      def end_scenario(test_case)
+        connections.each { |c| c.end_scenario(test_case) }
+      end
+
+      def snippets(code_keyword, step_name, multiline_arg_class_name)
+        connections.map { |c| c.snippet_text(code_keyword, step_name, multiline_arg_class_name) }.flatten
+      end
+
+    end
+  end
+end

data/lib/cucumber/wire/data_packet.rb

@@ -0,0 +1,34 @@
+require 'multi_json'
+
+module Cucumber
+  module Wire
+    # Represents the packet of data sent over the wire as JSON data, containing
+    # a message and a hash of arguments
+    class DataPacket
+      class << self
+        def parse(raw)
+          attributes = MultiJson.load(raw.strip)
+          message = attributes[0]
+          params  = attributes[1]
+          new(message, params)
+        end
+      end
+
+      attr_reader :message, :params
+
+      def initialize(message, params = nil)
+        @message, @params = message, params
+      end
+
+      def to_json
+        packet = [@message]
+        packet << @params if @params
+        MultiJson.dump(packet)
+      end
+
+      def handle_with(handler)
+        handler.send("handle_#{@message}", @params)
+      end
+    end
+  end
+end

data/lib/cucumber/wire/exception.rb

@@ -0,0 +1,32 @@
+module Cucumber
+  module Wire
+    # Proxy for an exception that occured at the remote end of the wire
+    class Exception < StandardError
+      module CanSetName
+        attr_writer :exception_name
+        def to_s
+          @exception_name
+        end
+      end
+
+      def initialize(args, config)
+        super args['message']
+        if args['exception']
+          self.class.extend(CanSetName)
+          self.class.exception_name = "#{args['exception']} from #{config}"
+        end
+        if args['backtrace']
+          @backtrace = if args['backtrace'].is_a?(String)
+              args['backtrace'].split("\n") # TODO: change cuke4nuke to pass an array instead of a big string
+            else
+              args['backtrace']
+            end
+        end
+      end
+
+      def backtrace
+        @backtrace || super
+      end
+    end
+  end
+end

data/lib/cucumber/wire/plugin.rb

@@ -0,0 +1,32 @@
+require 'cucumber/wire/connections'
+require 'cucumber/wire/add_hooks_filter'
+require 'cucumber/step_match_search'
+
+module Cucumber
+  module Wire
+    class Plugin
+      attr_reader :config
+      private :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def install
+        connections = Connections.new(wire_files.map { |f| create_connection(f) }, @config)
+        config.filters << Filters::ActivateSteps.new(StepMatchSearch.new(connections.method(:step_matches), @config), @config)
+        config.filters << AddHooksFilter.new(connections) unless @config.dry_run?
+        config.register_snippet_generator Snippet::Generator.new(connections)
+      end
+
+      def create_connection(wire_file)
+        Connection.new(Configuration.from_file(wire_file))
+      end
+
+      def wire_files
+        # TODO: change Cucumber's config object to allow us to get this information
+        config.send(:require_dirs).map { |dir| Dir.glob("#{dir}/**/*.wire") }.flatten
+      end
+    end
+  end
+end

data/lib/cucumber/wire/protocol.rb

@@ -0,0 +1,43 @@
+require 'cucumber/wire/protocol/requests'
+
+module Cucumber
+  module Wire
+    module Protocol
+      def step_matches(name_to_match)
+        handler = Requests::StepMatches.new(self)
+        handler.execute(name_to_match)
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class_name)
+        handler = Requests::SnippetText.new(self)
+        handler.execute(step_keyword, step_name, multiline_arg_class_name)
+      end
+
+      def invoke(step_definition_id, args)
+        handler = Requests::Invoke.new(self)
+        handler.execute(step_definition_id, args)
+      end
+
+      def diff_failed
+        handler = Requests::DiffFailed.new(self)
+        handler.execute
+      end
+
+      def diff_ok
+        handler = Requests::DiffOk.new(self)
+        handler.execute
+      end
+
+      def begin_scenario(scenario)
+        handler = Requests::BeginScenario.new(self)
+        handler.execute(scenario)
+      end
+
+      def end_scenario(scenario)
+        handler = Requests::EndScenario.new(self)
+        handler.execute(scenario)
+      end
+
+    end
+  end
+end

data/lib/cucumber/wire/protocol/requests.rb

@@ -0,0 +1,128 @@
+require 'cucumber/wire/request_handler'
+require 'cucumber/step_argument'
+
+module Cucumber
+  module Wire
+    module Protocol
+      module Requests
+        class StepMatches < RequestHandler
+          def execute(name_to_match)
+            @name_to_match = name_to_match
+            request_params = {
+              :name_to_match => name_to_match
+            }
+            super(request_params)
+          end
+
+          def handle_success(params)
+            params.map do |raw_step_match|
+              create_step_match(raw_step_match)
+            end
+          end
+
+          alias :handle_step_matches :handle_success
+
+          private
+
+          def create_step_match(raw_step_match)
+            step_definition = StepDefinition.new(@connection, raw_step_match)
+            step_args = raw_step_match['args'].map do |raw_arg|
+              StepArgument.new(raw_arg['pos'], raw_arg['val'])
+            end
+            step_match(step_definition, step_args)
+          end
+
+          def step_match(step_definition, step_args)
+            StepMatch.new(step_definition, @name_to_match, step_args)
+          end
+        end
+
+        class SnippetText < RequestHandler
+          def execute(step_keyword, step_name, multiline_arg_class_name)
+            request_params = {
+              :step_keyword => step_keyword,
+              :step_name => step_name,
+              :multiline_arg_class => multiline_arg_class_name
+            }
+            super(request_params)
+          end
+
+          def handle_success(snippet_text)
+            snippet_text
+          end
+
+          alias :handle_snippet_text :handle_success
+        end
+
+        class Invoke < RequestHandler
+          def execute(step_definition_id, args)
+            request_params = {
+              :id => step_definition_id,
+              :args => args
+            }
+            super(request_params)
+          end
+
+          def handle_pending(message)
+            raise Pending, message || "TODO"
+          end
+
+          def handle_diff!(tables)
+            # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
+            location = Core::Ast::Location.new(__FILE__, __LINE__)
+            table1 = table(tables[0], location)
+            table2 = table(tables[1], location)
+            table1.diff!(table2)
+          end
+
+          def handle_diff(tables)
+            begin
+              handle_diff!(tables)
+            rescue Cucumber::MultilineArgument::DataTable::Different
+              @connection.diff_failed
+            end
+            @connection.diff_ok
+          end
+
+          alias :handle_step_failed :handle_fail
+
+          private
+
+          def table(data, location)
+            Cucumber::MultilineArgument.from_core(Core::Ast::DataTable.new(data, location))
+          end
+        end
+
+        class DiffFailed < RequestHandler
+          alias :handle_step_failed :handle_fail
+        end
+
+        class DiffOk < RequestHandler
+          alias :handle_step_failed :handle_fail
+        end
+
+        class HookRequestHandler < RequestHandler
+          def execute(test_case)
+            super(request_params(test_case))
+          end
+
+          private
+
+          def request_params(test_case)
+            return nil unless test_case.tags.any?
+            { "tags" => clean_tag_names(test_case.tags) }
+          end
+
+          def clean_tag_names(tags)
+            tags.map { |tag| tag.name.gsub(/^@/, '') }.sort
+          end
+        end
+
+        BeginScenario = Class.new(HookRequestHandler)
+
+        EndScenario = Class.new(HookRequestHandler)
+
+      end
+    end
+  end
+end