cucumber 0.5.1 → 0.5.2

data/lib/cucumber/wire_support/configuration.rb

@@ -0,0 +1,18 @@
+module Cucumber
+  module WireSupport
+    class Configuration
+      attr_reader :host, :port
+      
+      def initialize(wire_file)
+        params = YAML.load_file(wire_file)
+        @host = params['host']
+        @port = params['port']
+        @timeouts = params['timeout'] || {}
+      end
+      
+      def timeout(message = nil)
+        return @timeouts[message.to_s] || 3
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/connection.rb

@@ -4,33 +4,35 @@ require 'cucumber/wire_support/wire_protocol'
 module Cucumber
   module WireSupport
     class Connection
+      class ConnectionError < StandardError; end
+        
       include WireProtocol
       
       def initialize(config)
-        @host, @port = config['host'], config['port']
+        @config = config
       end
       
-      def call_remote(response_handler, message, params)
-        timeout = 3
+      def call_remote(request_handler, message, params)
         packet = WirePacket.new(message, params)
 
         begin
-          send_data_to_socket(packet.to_json, timeout)
-          response = fetch_data_from_socket(timeout)
-          response.handle_with(response_handler)
-        rescue Timeout::Error
-          raise "Timed out calling server with message #{message}"
+          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)
-        WireException.new(params, @host, @port)
+        WireException.new(params, @config.host, @config.port)
       end
 
       private
       
-      def send_data_to_socket(data, timeout)
-        Timeout.timeout(timeout) { socket.puts(data) }
+      def send_data_to_socket(data)
+        Timeout.timeout(@config.timeout) { socket.puts(data) }
       end
 
       def fetch_data_from_socket(timeout)
@@ -39,7 +41,9 @@ module Cucumber
       end
 
       def socket
-        @socket ||= TCPSocket.new(@host, @port)
+        @socket ||= TCPSocket.new(@config.host, @config.port)
+      rescue Errno::ECONNREFUSED => exception
+        raise(ConnectionError, "Unable to contact the wire server at #{@config.host}:#{@config.port}. Is it up?")
       end
     end
   end

data/lib/cucumber/wire_support/request_handler.rb

@@ -1,19 +1,29 @@
 module Cucumber
   module WireSupport
     class RequestHandler
-      def initialize(connection, message, &block)
+      def initialize(connection)
         @connection = connection
-        @message = message
-        instance_eval(&block) if block
+        @message = underscore(self.class.name.split('::').last)
       end
 
-      def execute(request_params)
+      def execute(request_params = nil)
         @connection.call_remote(self, @message, request_params)
       end
 
       def handle_fail(params)
         raise @connection.exception(params)
       end
+      
+      private
+      
+      # Props to Rails
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
     end
   end
 end

data/lib/cucumber/wire_support/wire_language.rb

@@ -8,6 +8,7 @@ EOM
   exit(1)
 end
 require 'cucumber/wire_support/connection'
+require 'cucumber/wire_support/configuration'
 require 'cucumber/wire_support/wire_packet'
 require 'cucumber/wire_support/wire_exception'
 require 'cucumber/wire_support/wire_step_definition'
@@ -15,19 +16,11 @@ require 'cucumber/wire_support/wire_step_definition'
 module Cucumber
   module WireSupport
     
-    # The wire-protocol (lanugage independent) implementation of the programming language API.
+    # The wire-protocol (lanugage independent) implementation of the programming 
+    # language API.
     class WireLanguage
       include LanguageSupport::LanguageMethods
-      
-      def load_code_file(wire_file)
-        config = YAML.load_file(wire_file)
-        @connections << Connection.new(config)
-      end
-      
-      def step_matches(step_name, formatted_step_name)
-        @connections.map{ |remote| remote.step_matches(step_name, formatted_step_name)}.flatten
-      end
-      
+
       def initialize(step_mother)
         @connections = []
       end
@@ -35,6 +28,11 @@ module Cucumber
       def alias_adverbs(adverbs)
       end
 
+      def load_code_file(wire_file)
+        config = Configuration.new(wire_file)
+        @connections << Connection.new(config)
+      end
+      
       def snippet_text(step_keyword, step_name, multiline_arg_class)
         snippets = @connections.map do |remote| 
           remote.snippet_text(step_keyword, step_name, multiline_arg_class.to_s)
@@ -42,6 +40,10 @@ module Cucumber
         snippets.flatten.join("\n")
       end
       
+      def step_matches(step_name, formatted_step_name)
+        @connections.map{ |remote| remote.step_matches(step_name, formatted_step_name)}.flatten
+      end
+      
       protected
       
       def begin_scenario(scenario)
@@ -51,12 +53,6 @@ module Cucumber
       def end_scenario
         @connections.each { |remote| remote.end_scenario }
       end
-      
-      private
-      
-      def step_definitions
-        @step_definitions ||= {}
-      end
     end
   end
 end

data/lib/cucumber/wire_support/wire_protocol.rb

@@ -1,108 +1,44 @@
 require 'cucumber/step_argument'
-require 'cucumber/wire_support/request_handler'
+require 'cucumber/wire_support/wire_protocol/requests'
 
 module Cucumber
   module WireSupport
     module WireProtocol
       def step_matches(name_to_match, name_to_report)
-        @name_to_match, @name_to_report = name_to_match, name_to_report
-        make_request(:step_matches, :name_to_match => name_to_match) do
-          def handle_step_matches(params)
-            params.map do |raw_step_match|
-              step_definition = WireStepDefinition.new(@connection, raw_step_match)
-              step_args = raw_step_match['args'].map do |raw_arg|
-                StepArgument.new(raw_arg['val'], raw_arg['pos'])
-              end
-              @connection.step_match(step_definition, step_args) # convoluted!
-            end
-          end
-        end
+        handler = Requests::StepMatches.new(self)
+        handler.execute(name_to_match, name_to_report)
       end
 
-      def step_match(step_definition, step_args)
-        StepMatch.new(step_definition, @name_to_match, @name_to_report, step_args)
-      end
-      
       def snippet_text(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 }
-
-        make_request(:snippet_text, request_params) do
-          def handle_snippet_text(text)
-            text
-          end
-        end
+        handler = Requests::SnippetText.new(self)
+        handler.execute(step_keyword, step_name, multiline_arg_class_name)
       end
       
       def invoke(step_definition_id, args)
-        request_params = { :id => step_definition_id, :args => args }
-
-        make_request(:invoke, request_params) do
-          def handle_success(params)
-          end
-          
-          def handle_pending(message)
-            raise Pending, message || "TODO"
-          end
-          
-          def handle_diff(tables)
-            table1 = Ast::Table.new(tables[0])
-            table2 = Ast::Table.new(tables[1])
-            begin
-              table1.diff!(table2)
-            rescue Cucumber::Ast::Table::Different
-              @connection.diff_failed
-            end
-            @connection.diff_ok
-          end
-        
-          def handle_step_failed(params)
-            handle_fail(params)
-          end
-        end
+        handler = Requests::Invoke.new(self)
+        handler.execute(step_definition_id, args)
       end
       
       def diff_failed
-        make_request(:diff_failed) do
-          def handle_success(params)
-          end
-          
-          def handle_step_failed(params)
-            handle_fail(params)
-          end
-        end
+        handler = Requests::DiffFailed.new(self)
+        handler.execute
       end
       
       def diff_ok
-        make_request(:diff_ok) do
-          def handle_success(params)
-          end
-          
-          def handle_step_failed(params)
-            handle_fail(params)
-          end
-        end
+        handler = Requests::DiffOk.new(self)
+        handler.execute
       end
       
       def begin_scenario(scenario)
-        make_request(:begin_scenario) do
-          def handle_success(params)
-          end
-        end
+        handler = Requests::BeginScenario.new(self)
+        handler.execute(scenario)
       end
 
       def end_scenario
-        make_request(:end_scenario) do
-          def handle_success(params)
-          end
-        end
+        handler = Requests::EndScenario.new(self)
+        handler.execute
       end
       
-      private
-      
-      def make_request(request_message, params = nil, &block)
-        handler = RequestHandler.new(self, request_message, &block)
-        handler.execute(params)
-      end
     end
   end
 end

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -0,0 +1,113 @@
+require 'cucumber/wire_support/request_handler'
+module Cucumber
+  module WireSupport
+    module WireProtocol
+      module Requests
+        class StepMatches < RequestHandler
+          def execute(name_to_match, name_to_report)
+            @name_to_match, @name_to_report = name_to_match, name_to_report
+            request_params = {
+              :name_to_match => name_to_match
+            }
+            super(request_params)
+          end
+
+          def handle_step_matches(params)
+            params.map do |raw_step_match|
+              step_definition = WireStepDefinition.new(@connection, raw_step_match)
+              step_args = raw_step_match['args'].map do |raw_arg|
+                StepArgument.new(raw_arg['val'], raw_arg['pos'])
+              end
+              step_match(step_definition, step_args)
+            end
+          end
+        
+          private
+        
+          def step_match(step_definition, step_args)
+            StepMatch.new(step_definition, @name_to_match, @name_to_report, 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_snippet_text(text)
+            text
+          end
+        end
+
+        class Invoke < RequestHandler
+          def execute(step_definition_id, args)
+            request_params = { 
+              :id => step_definition_id, 
+              :args => args
+            }
+            super(request_params)
+          end
+
+          def handle_success(params)
+          end
+        
+          def handle_pending(message)
+            raise Pending, message || "TODO"
+          end
+        
+          def handle_diff(tables)
+            table1 = Ast::Table.new(tables[0])
+            table2 = Ast::Table.new(tables[1])
+            begin
+              table1.diff!(table2)
+            rescue Cucumber::Ast::Table::Different
+              @connection.diff_failed
+            end
+            @connection.diff_ok
+          end
+      
+          def handle_step_failed(params)
+            handle_fail(params)
+          end
+        end
+
+        class DiffFailed < RequestHandler
+          def handle_success(params)
+          end
+        
+          def handle_step_failed(params)
+            handle_fail(params)
+          end
+        end
+      
+        class DiffOk < RequestHandler
+          def handle_success(params)
+          end
+        
+          def handle_step_failed(params)
+            handle_fail(params)
+          end
+        end
+      
+        class BeginScenario < RequestHandler
+          def execute(scenario)
+            super(nil) # not passing the scenario yet
+          end
+
+          def handle_success(params)
+          end
+        end
+
+        class EndScenario < RequestHandler
+          def handle_success(params)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/html_spec.rb

@@ -21,6 +21,7 @@ module Cucumber
       before(:each) do
         @out = StringIO.new
         @formatter = Html.new(step_mother, @out, {})
+        step_mother.visitor = @formatter
       end
     
       it "should not raise an error when visiting a blank feature name" do
@@ -205,6 +206,19 @@ module Cucumber
           it { @doc.should_not have_css_node('.feature .scenario .step.failed', //) }
           it { @doc.should have_css_node('.feature .scenario .step.undefined', /yay/) }
         end
+
+        describe "with a step that embeds a snapshot" do
+          define_steps do
+            Given(/snap/) { embed('snapshot.jpeg', 'image/jpeg') }
+          end
+
+          define_feature(<<-FEATURE)
+            Scenario:
+              Given snap
+            FEATURE
+
+          it { @doc.css('.embed img').first.attributes['src'].to_s.should == "snapshot.jpeg" }
+        end
       
       end
     end

data/spec/cucumber/wire_support/configuration_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/wire_support/wire_language'
+require 'tempfile'
+
+module Cucumber
+  module WireSupport
+    describe Configuration do
+      it "should read the hostname / port from the file" do
+        wire_file = Tempfile.new('wire')
+        wire_file << %q{
+          host: localhost
+          port: 54321
+        }
+        wire_file.close
+        config = Configuration.new(wire_file.path)
+        config.host.should == 'localhost'
+        config.port.should == 54321
+      end
+      
+      it "should read the timeout for a specific message" do
+        wire_file = Tempfile.new('wire')
+        wire_file << %q{
+          host: localhost
+          port: 54321
+          timeout:
+            invoke: 99
+        }
+        wire_file.close
+        config = Configuration.new(wire_file.path)
+        config.timeout(:invoke).should == 99
+      end
+    end
+  end
+end