combi 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57984131b9c91dbbc19bcf4452f74c3396149a70
-  data.tar.gz: 922c99d9c61e3fd1b6441be10834ff915bc34de3
+  metadata.gz: e8d52d86d25a8990c1034e0acfaadb4417164c07
+  data.tar.gz: 90ae51a9bf47ce6a2ff6fcfe13ea95fb076a8ba6
 SHA512:
-  metadata.gz: f76796d8fc85770a6033a05221fca650bcf4f5246940af218866940fd2d6a445838ec44a7a59557cfe4270192a4c29d929775201849e83994a60d27c9e660a79
-  data.tar.gz: 452d3fbca7a3d29d14852533adcd48b1bfe6ae740fabb920abbea76885ac63720c79bcb52d91e0b627ec2c5a4f2af72f87d86d471fce724ed860a570760a4922
+  metadata.gz: 67235e10e87a924be9c053eead194bf0f6f30f47682a3c13a204d0f77d01354810841664116b2791ae2ade902103d0f9a1c2fe31ca8e6bf6771aa6c7b68b829e
+  data.tar.gz: 0d5f694d3db7fc22d18a01cc40d64474a296e4811bf40ac9084347e7c89ae17cc824165c3a7729cc0430a034d6a1e2bcf84aa7d91666bae54917d4f16caeb5ac

data/lib/combi/buses/bus.rb

@@ -21,9 +21,6 @@ module Combi
       service_instance.actions.each do |service_name|
         self.add_routes_for(service_name, service_instance)
       end
-      service_instance.fast_actions.each do |service_name|
-        self.add_routes_for(service_name, service_instance, fast: true)
-      end
       service_instance.setup(self, options[:context])
     end
 
@@ -93,16 +90,16 @@ module Combi
       service_class.new
     end
 
-    def add_routes_for(service_name, service_instance, options = {})
+    def add_routes_for(service_name, service_instance)
       service_instance.remote_methods.each do |method|
-        add_route_for(service_name, method, service_instance, options)
+        add_route_for(service_name, method, service_instance)
       end
     end
 
-    def add_route_for(service_name, action_name, service_instance, options = {})
+    def add_route_for(service_name, action_name, service_instance)
       path = [service_name, action_name].join('/')
       puts "New route: #{path} :: #{service_instance}"
-      @routes[path] = {service_instance: service_instance, options: options}
+      @routes[path] = service_instance
     end
 
     # Funny name of a exception used to signal that the requested
@@ -114,14 +111,10 @@ module Combi
 
     def resolve_route(service_name, kind)
       path = [service_name, kind].join('/')
-      handler = @routes[path]
-      if handler
-        return service_instance = handler[:service_instance]
-      else
-        log "[WARNING] Service Path #{path} not found"
-        log "[WARNING] routes: #{@routes.keys.inspect}"
-        raise UnknownStop.new(path)
-      end
+      return @routes[path] if @routes[path]
+      log "[WARNING] Service Path #{path} not found"
+      log "[WARNING] routes: #{@routes.keys.inspect}"
+      raise UnknownStop.new(path)
     end
 
     def invoke_service(service_name, action, params)

data/lib/combi/buses/http.rb

@@ -53,17 +53,21 @@ module Combi
     def request(name, kind, message, options = {})
       options[:timeout] ||= RPC_DEFAULT_TIMEOUT
 
-      correlation_id = Combi::Correlation.generate
-      waiter = @response_store.wait_for(correlation_id, options[:timeout])
       url = "#{@options[:remote_api]}#{name}/#{kind}"
       message_json = Yajl::Encoder.encode(message)
       request_async = EventMachine::HttpRequest.new(url, connection_timeout: options[:timeout]).post(body: message_json)
-      request_async.callback do |r|
-        parsed = Yajl::Parser.parse(r.response, symbolize_keys: true)
-        waiter.succeed(parsed)
-      end
-      request_async.errback do |x|
-        waiter.fail(Timeout::Error.new)
+      if options[:fast]
+        waiter = nil
+      else
+        correlation_id = Combi::Correlation.generate
+        waiter = @response_store.wait_for(correlation_id, options[:timeout])
+        request_async.callback do |r|
+          parsed = Yajl::Parser.parse(r.response, symbolize_keys: true)
+          waiter.succeed(parsed)
+        end
+        request_async.errback do |x|
+          waiter.fail(Timeout::Error.new)
+        end
       end
       waiter
     end

data/lib/combi/buses/in_process.rb

@@ -5,22 +5,32 @@ module Combi
 
     def request(service_name, kind, message, options = {})
       options[:timeout] ||= RPC_DEFAULT_TIMEOUT
-      waiter = EventMachine::DefaultDeferrable.new
-      begin
-        Timeout.timeout(options[:timeout]) do
-          message = Yajl::Parser.parse(Yajl::Encoder.encode(message), symbolize_keys: true)
-          response = invoke_service(service_name, kind, message)
-          response.callback do |service_response|
-            waiter.succeed service_response
+      message = Yajl::Parser.parse(Yajl::Encoder.encode(message), symbolize_keys: true)
+      if options[:fast]
+        operation = Proc.new do
+          Timeout.timeout(options[:timeout]) do
+            invoke_service(service_name, kind, message)
           end
-          response.errback do |service_response|
-            waiter.fail error: service_response
+        end
+        EM::defer operation
+        return nil
+      else
+        waiter = EventMachine::DefaultDeferrable.new
+        begin
+          Timeout.timeout(options[:timeout]) do
+            response = invoke_service(service_name, kind, message)
+            response.callback do |service_response|
+              waiter.succeed service_response
+            end
+            response.errback do |service_response|
+              waiter.fail error: service_response
+            end
           end
+        rescue Timeout::Error => e
+          waiter.fail error: 'Timeout::Error'
         end
-      rescue Timeout::Error => e
-        waiter.fail error: 'Timeout::Error'
+        waiter
       end
-      waiter
     end
   end
 end

data/lib/combi/buses/queue.rb

@@ -25,57 +25,61 @@ module Combi
       end
     end
 
-    def add_routes_for(service_name, service_instance, options = {})
-      create_queue_for_service(service_name, options)
+    def add_routes_for(service_name, service_instance)
+      create_queue_for_service(service_name)
       super
     end
 
-    def create_queue_for_service(service_name, options = {})
+    def create_queue_for_service(service_name)
       log "creating queue #{service_name}"
       queue_options = {}
       subscription_options = {}
-      if options[:fast] == true
-        queue_options[:auto_delete] = false
-      else
-        subscription_options[:ack] = true
-      end
+      subscription_options[:ack] = true
       queue_service.ready do
         queue_service.queue(service_name.to_s, queue_options) do |queue|
-          log "subscribing to queue #{service_name.to_s} with options #{queue_options}"
+          log "subscribing to queue #{service_name.to_s}"
           queue.subscribe(subscription_options) do |delivery_info, payload|
-            respond service_name, payload, delivery_info
-            queue_service.acknowledge delivery_info unless options[:fast] == true
+            process_queue_message service_name, payload, delivery_info
+            queue_service.acknowledge delivery_info
           end
         end
       end
     end
 
-    def request(name, kind, message, options = {})
-      log "Preparing request: #{name}.#{kind} #{message.inspect[0..500]}\t|| #{options.inspect}"
-      options[:timeout] ||= RPC_DEFAULT_TIMEOUT
-      options[:routing_key] = name.to_s
-      correlation_id = Combi::Correlation.generate
-      options[:correlation_id] = correlation_id
-      waiter = @response_store.wait_for(correlation_id, options[:timeout])
+    def request(name, kind, message, timeout: RPC_DEFAULT_TIMEOUT, fast: false)
+      log "Preparing request: #{name}.#{kind} #{message.inspect[0..500]}\t|| timeout: #{timeout} fast: #{fast}"
+      options = {
+        timeout: timeout,
+        routing_key: name.to_s
+      }
+      if fast
+        waiter = nil
+      else
+        correlation_id = Combi::Correlation.generate
+        options[:correlation_id] = correlation_id
+        waiter = @response_store.wait_for correlation_id, timeout
+      end
       queue_service.next_ready_only do
         log "Making request: #{name}.#{kind} #{message.inspect[0..500]}\t|| #{options.inspect[0..500]}"
-        queue_service.call(kind, message, options)
+        queue_service.publish_request(kind, message, options)
       end
       waiter
     end
 
-    def respond(service_name, request, delivery_info)
+    def process_queue_message(service_name, request, delivery_info)
       message = Yajl::Parser.parse request, symbolize_keys: true
       kind = message[:kind]
       payload = message[:payload]
       options = message[:options]
       response = invoke_service(service_name, kind, payload)
-      response.callback do |service_response|
-        queue_service.respond service_response, delivery_info
-      end
-      response.errback do |service_response|
-        failure_response = { error: service_response }
-        queue_service.respond failure_response, delivery_info
+      if delivery_info.reply_to
+        response.callback do |service_response|
+          queue_service.respond service_response, delivery_info
+        end
+        response.errback do |service_response|
+          failure_response = { error: service_response }
+          queue_service.respond failure_response, delivery_info
+        end
       end
     end
 

data/lib/combi/buses/web_socket.rb

@@ -32,10 +32,6 @@ module Combi
         session && session.close
       end
 
-      def ws
-        @ws
-      end
-
     end
 
     class Client
@@ -52,7 +48,7 @@ module Combi
       end
 
       def stop!
-        @ws && @ws.close
+        ws && ws.close
         @bus.log "stop requested"
       end
 
@@ -90,7 +86,6 @@ module Combi
       end
 
       def ws
-        @bus.log "ws present: #{@ws != nil}"
         @ws
       end
 
@@ -175,32 +170,41 @@ module Combi
         response = {error: {klass: e.class.name, message: e.message, backtrace: e.backtrace } }
       end
 
-      msg = {result: 'ok', correlation_id: message[:correlation_id]}
+      if message[:correlation_id]
+        # The client is insterested in a response
+        msg = {result: 'ok', correlation_id: message[:correlation_id]}
 
-      response.callback do |service_response|
-        msg[:response] = service_response
-        serialized = Yajl::Encoder.encode msg
-        ws.send serialized
-      end
-      response.errback do |service_response|
-        msg[:response] = {error: service_response}
-        serialized = Yajl::Encoder.encode msg
-        ws.send serialized
+        response.callback do |service_response|
+          msg[:response] = service_response
+          send_response ws, msg
+        end
+        response.errback do |service_response|
+          msg[:response] = {error: service_response}
+          send_response ws, msg
+        end
       end
     end
 
-    def request(name, kind, message, options = {})
-      options[:timeout] ||= RPC_DEFAULT_TIMEOUT
-      correlation_id = Combi::Correlation.generate
+    def send_response(ws, message)
+      serialized = Yajl::Encoder.encode message
+      ws.send serialized
+    end
+
+    def request(name, kind, message, timeout: RPC_DEFAULT_TIMEOUT, fast: false, ws: nil)
       msg = {
         service: name,
         kind: kind,
-        payload: message,
-        correlation_id: correlation_id
+        payload: message
       }
-      waiter = @response_store.wait_for(correlation_id, options[:timeout])
+      if fast
+        waiter = nil
+      else
+        correlation_id = Combi::Correlation.generate
+        msg[:correlation_id] = correlation_id
+        waiter = @response_store.wait_for(correlation_id, timeout)
+      end
       @ready.callback do |r|
-        web_socket = @machine.ws || options[:ws]
+        web_socket = @machine.respond_to?(:ws) ? @machine.ws : ws
         unless web_socket.nil?
           serialized = Yajl::Encoder.encode msg
           log "sending request #{serialized}"

data/lib/combi/queue_service.rb

@@ -114,12 +114,13 @@ module Combi
       end
     end
 
-    def call(kind, message, options = {})
-      log "sending request #{kind} #{message.inspect[0..500]} with options #{options.inspect}"
-      raise "RPC is not enabled or reply_to is not included" if (@rpc_queue.nil? || @rpc_queue.name.nil?) && options[:reply_to].nil?
+    def publish_request(kind, message, options = {})
+      if options.has_key? :correlation_id
+        # wants a response
+        options[:reply_to] = @rpc_queue.name
+      end
       options[:expiration] = ((options[:timeout] || RPC_DEFAULT_TIMEOUT) * 1000).to_i
-      options[:routing_key] ||= 'rcalls_queue'
-      options[:reply_to] ||= @rpc_queue.name
+      log "sending request #{kind} #{message.inspect[0..500]} with options #{options.inspect}"
       request = Yajl::Encoder.encode kind: kind, payload: message, options: {}
       publish request, options
     end

data/lib/combi/service.rb

@@ -6,6 +6,7 @@ module Combi
       context[:service_bus] = service_bus
       setup_context(context)
       setup_services
+      self
     end
 
     def setup_context(context)
@@ -32,10 +33,6 @@ module Combi
       []
     end
 
-    def fast_actions
-      []
-    end
-
     def remote_methods
       @_REMOTE_METHODS ||= public_methods(false) - Combi::Service.public_instance_methods
     end

data/lib/combi/version.rb

@@ -1,3 +1,3 @@
 module Combi
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/spec/lib/combi/buses/bus_spec.rb

@@ -17,7 +17,7 @@ describe 'Combi::Bus' do
       Given(:path) { 'class/remote' }
       When { bus.add_service service_definition }
       Then { bus.routes.keys.length == 1 }
-      And  { bus.routes[path][:service_instance] == service_definition }
+      And  { bus.routes[path] == service_definition }
     end
 
     context 'via modules' do
@@ -34,7 +34,7 @@ describe 'Combi::Bus' do
         puts bus.routes.keys.inspect
       }
       Then { bus.routes.keys.length == 1 }
-      And  { bus.routes[path][:service_instance].is_a? service_definition }
+      And  { bus.routes[path].is_a? service_definition }
     end
   end
 end

data/spec/lib/combi/buses/queue_spec.rb

@@ -49,6 +49,24 @@ describe 'Combi::Queue' do
     end
   end
 
+  context 'fire and forget' do
+    describe 'does not send a response' do
+      When(:service) { provider.add_service null_service }
+      Then do
+        em do
+          expect(provider.queue_service).not_to receive(:respond)
+          expect(service).to receive(:do_it) do
+            done
+            provider.stop!
+            consumer.stop!
+          end
+          prepare
+          consumer.request :null, :do_it, {}, fast: true
+        end
+      end
+    end
+  end
+
   context "it resist a reconnection" do
     puts "VERY UNSTABLE TEST"
     When(:service) { provider.add_service null_service }

data/spec/lib/combi/buses/web_socket_spec.rb

@@ -46,6 +46,23 @@ describe 'Combi::WebSocket' do
     end
   end
 
+  context 'fire and forget' do
+    describe 'does not send a response' do
+      When(:service) { provider.add_service null_service }
+      Then do
+        em do
+          expect(provider).not_to receive(:send_response)
+          expect(service).to receive(:do_it) do
+            done
+            provider.stop!
+            consumer.stop!
+          end
+          prepare
+          consumer.request :null, :do_it, {}, fast: true
+        end
+      end
+    end
+  end
 
   context 'it notify when the connection is opened' do
     Then do

data/spec/shared_examples/standard_bus.rb

@@ -38,165 +38,254 @@ shared_examples_for "standard_bus" do
     end
   end
 
+  Given(:calculator_service) do
+    Module.new do
+      def actions; [:calculator]; end
+      def incr(params)
+        @counter += 1
+      end
+      def initialize
+        @counter = 0
+      end
+      def counter
+        @counter
+      end
+    end
+  end
+
   Given(:finalize) do
     provider.stop!
     consumer.stop!
   end
 
-  context 'can invoke services' do
-    When(:service) { provider.add_service boring_salutation_service }
-    When(:params) { { who: 'world' } }
-    Then do
-      em do
-        prepare
-        EM.synchrony do
-          service_result = EM::Synchrony.sync consumer.request(:say_hello, :do_it, params, { timeout: 2 })
-          service_result.should eq "Hello world"
-          done
-          finalize
+  context 'fire and forget' do
+    context 'can invoke services' do
+      When(:service) { provider.add_service calculator_service }
+      When(:params) { { who: 'world' } }
+      When(:service_response) do
+        srv_resp = "UNSET"
+        em do
+          prepare
+          EM.synchrony do
+            srv_resp = consumer.request(:calculator, :incr, {}, {fast: true})
+            spec_waiter = EM::DefaultDeferrable.new
+            EM.add_periodic_timer 0.1 do
+              spec_waiter.succeed service.counter if service.counter == 1
+            end
+            EM::Synchrony.sync spec_waiter
+            done
+            finalize
+          end
         end
+        srv_resp
       end
+      Then { service_response.should_not be_a EM::Deferrable }
+      And { service_response.should be_nil }
+      And { service.counter.should eq 1 }
     end
-  end
 
-  context 'fails with error => Timeout::Error when the response is slow' do
-    Given(:time_base) { 0.01 }
-    When(:params) { { time: time_base*4 } }
-    When(:service) { provider.add_service slow_service }
-    Then do
-      em do
-        prepare
-        EM.synchrony do
-          service_result = EM::Synchrony.sync consumer.request(:sleep, :do_it, params, { timeout: time_base/2.0 })
-          service_result.should be_a Hash
-          service_result.should have_key :error
-          service_result[:error].should eq 'Timeout::Error'
-          done(time_base) #timeout response must came before this timeout
+    context 'ignores service errors' do
+      Given(:error_message) { 'service is broken' }
+      When(:service) { provider.add_service broken_service }
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            service_result = consumer.request(:shout_error, :do_it, {message: error_message}, { fast: true })
+            service_result.should be_nil
+            done
+            finalize
+          end
         end
-        finalize
       end
     end
-  end
 
-  context 'return the same data type returned by service' do
-    Given(:result_container) { {} }
-    Given(:params) { { data: data } }
-    When(:service) { provider.add_service echo_service }
-    When('service is called') do
-      em do
-        prepare
-        EM.synchrony do
-          result_container[:result] = EM::Synchrony.sync consumer.request(:echo_this, :do_it, params)
-          done
-          finalize
+    context 'ignores unknown services' do
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            service_result = consumer.request(:mssing_service, :do_it, {}, { fast: true })
+            service_result.should be_nil
+            done
+            finalize
+          end
         end
       end
     end
+  end
 
-    context 'for string' do
-      Given(:data) { "a simple string" }
-      Then { result_container[:result].should eq data}
+  context 'ignores service errors' do
+      When(:service) { provider.add_service boring_salutation_service }
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            service_result = consumer.request(:say_hello, :to_no_one, {}, { fast: true })
+            service_result.should be_nil
+            done
+            finalize
+          end
+        end
+      end
     end
 
-    context 'for numbers' do
-      Given(:data) { 237.324 }
-      Then { result_container[:result].should eq data}
+  context 'expecting response' do
+    context 'can invoke services' do
+      When(:service) { provider.add_service boring_salutation_service }
+      When(:params) { { who: 'world' } }
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            service_result = EM::Synchrony.sync consumer.request(:say_hello, :do_it, params, { timeout: 2 })
+            service_result.should eq "Hello world"
+            done
+            finalize
+          end
+        end
+      end
     end
 
-    context 'for arrays' do
-      Given(:data) { [1, 2, 3.0, "4", "cinco"]}
-      Then { result_container[:result].should eq data}
+    context 'fails with error => Timeout::Error when the response is slow' do
+      Given(:time_base) { 0.01 }
+      When(:params) { { time: time_base*4 } }
+      When(:service) { provider.add_service slow_service }
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            service_result = EM::Synchrony.sync consumer.request(:sleep, :do_it, params, { timeout: time_base/2.0 })
+            service_result.should be_a Hash
+            service_result.should have_key :error
+            service_result[:error].should eq 'Timeout::Error'
+            done(time_base) #timeout response must came before this timeout
+          end
+          finalize
+        end
+      end
     end
 
-    context 'for symbols always return a string' do
-      Given(:data) { :some_symbol }
-      Then { result_container[:result].should eq data.to_s}
-    end
+    context 'return the same data type returned by service' do
+      Given(:result_container) { {} }
+      Given(:params) { { data: data } }
+      When(:service) { provider.add_service echo_service }
+      When('service is called') do
+        em do
+          prepare
+          EM.synchrony do
+            result_container[:result] = EM::Synchrony.sync consumer.request(:echo_this, :do_it, params)
+            done
+            finalize
+          end
+        end
+      end
 
-    context 'for maps' do
-      context 'with string keys' do
-        Given(:data) { {'a' => 1, 'b' => 'dos'} }
-        Then { result_container[:result].keys.should eq data.keys.map(&:to_sym)}
-        And  { result_container[:result].values.should eq data.values }
+      context 'for string' do
+        Given(:data) { "a simple string" }
+        Then { result_container[:result].should eq data}
       end
-      context 'with symbol keys' do
-        Given(:data) { {a: 1, b: 'dos'} }
+
+      context 'for numbers' do
+        Given(:data) { 237.324 }
         Then { result_container[:result].should eq data}
       end
-    end
 
-    context 'for objects returns their json version' do
-      Given(:custom_json) { {val: 'value'} }
-      Given(:custom_class) do
-        Class.new do
-          def initialize(custom_json)
-            @custom_json = custom_json
-          end
-          def to_json
-            @custom_json
+      context 'for arrays' do
+        Given(:data) { [1, 2, 3.0, "4", "cinco"]}
+        Then { result_container[:result].should eq data}
+      end
+
+      context 'for symbols always return a string' do
+        Given(:data) { :some_symbol }
+        Then { result_container[:result].should eq data.to_s}
+      end
+
+      context 'for maps' do
+        context 'with string keys' do
+          Given(:data) { {'a' => 1, 'b' => 'dos'} }
+          Then { result_container[:result].keys.should eq data.keys.map(&:to_sym)}
+          And  { result_container[:result].values.should eq data.values }
+        end
+        context 'with symbol keys' do
+          Given(:data) { {a: 1, b: 'dos'} }
+          Then { result_container[:result].should eq data}
+        end
+      end
+
+      context 'for objects returns their json version' do
+        Given(:custom_json) { {val: 'value'} }
+        Given(:custom_class) do
+          Class.new do
+            def initialize(custom_json)
+              @custom_json = custom_json
+            end
+            def to_json
+              @custom_json
+            end
           end
         end
+        Given(:data) { custom_class.new(custom_json).to_json}
+        Then { result_container[:result].should eq custom_json}
       end
-      Given(:data) { custom_class.new(custom_json).to_json}
-      Then { result_container[:result].should eq custom_json}
     end
-  end
 
-  context 'return something when service raise an error' do
-    Given(:error_message) { 'service is broken' }
-    When(:service) { provider.add_service broken_service }
-    Then do
-      em do
-        prepare
-        EM.synchrony do
-          service_result = EM::Synchrony.sync consumer.request(:shout_error, :do_it, {message: error_message}, { timeout: 0.1 })
-          service_result[:error].should be_a Hash
-          service_result[:error][:message].should eq error_message
-          service_result[:error][:backtrace].should_not be_nil
-          service_result[:error][:backtrace].should be_an Array
-          done
-          finalize
+    context 'return something when service raise an error' do
+      Given(:error_message) { 'service is broken' }
+      When(:service) { provider.add_service broken_service }
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            service_result = EM::Synchrony.sync consumer.request(:shout_error, :do_it, {message: error_message}, { timeout: 0.1 })
+            service_result[:error].should be_a Hash
+            service_result[:error][:message].should eq error_message
+            service_result[:error][:backtrace].should_not be_nil
+            service_result[:error][:backtrace].should be_an Array
+            done
+            finalize
+          end
         end
       end
     end
-  end
 
-  context 'return an error when requesting an unknown service' do
-    Given(:error_message) { Combi::Bus::UnknownStop.name }
-    When(:service) { provider.add_service broken_service }
-    Then do
-      em do
-        prepare
-        EM.synchrony do
-          begin
-            service_result = EM::Synchrony.sync consumer.request(:some_not_service, :do_it, {}, { timeout: 0.1 })
-            if defined?(Combi::Queue) and consumer.class == Combi::Queue
-              service_result[:error].should eq "Timeout::Error"
-            else
-              service_result[:error][:klass].should eq error_message
-              service_result[:error][:message].should eq 'some_not_service/do_it'
+    context 'return an error when requesting an unknown service' do
+      Given(:error_message) { Combi::Bus::UnknownStop.name }
+      When(:service) { provider.add_service broken_service }
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            begin
+              service_result = EM::Synchrony.sync consumer.request(:some_not_service, :do_it, {}, { timeout: 0.1 })
+              if defined?(Combi::Queue) and consumer.class == Combi::Queue
+                service_result[:error].should eq "Timeout::Error"
+              else
+                service_result[:error][:klass].should eq error_message
+                service_result[:error][:message].should eq 'some_not_service/do_it'
+              end
+              done
+              finalize
             end
-            done
-            finalize
           end
         end
       end
     end
-  end
 
-  context 'return an error when requesting an unknown action for the service' do
-    Given(:error_message) { Combi::Bus::UnknownStop.name }
-    When(:service) { provider.add_service echo_service }
-    Then do
-      em do
-        prepare
-        EM.synchrony do
-          begin
-            service_result = EM::Synchrony.sync consumer.request(:echo_this, :do_other, {}, { timeout: 0.1 })
-            service_result[:error][:klass].should eq error_message
-            service_result[:error][:message].should eq 'echo_this/do_other'
-            done
-            finalize
+    context 'return an error when requesting an unknown action for the service' do
+      Given(:error_message) { Combi::Bus::UnknownStop.name }
+      When(:service) { provider.add_service echo_service }
+      Then do
+        em do
+          prepare
+          EM.synchrony do
+            begin
+              service_result = EM::Synchrony.sync consumer.request(:echo_this, :do_other, {}, { timeout: 0.1 })
+              service_result[:error][:klass].should eq error_message
+              service_result[:error][:message].should eq 'echo_this/do_other'
+              done
+              finalize
+            end
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: combi
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - German Del Zotto