wamp_client 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87be6cf98c5f02b19c59566bd0dca4c740bc72ea
-  data.tar.gz: 027fdc23b28f45c66f527716fe5836e8cd0aa093
+  metadata.gz: 38ed148dd65f5a524eef4a6f6d6adaf6d832b2e4
+  data.tar.gz: 6987c5eea6218af8562546b159a1355a8fc9493f
 SHA512:
-  metadata.gz: 684135ebcb5a497b45d40f526dcd94dc59ac5f4c914681c6a6c790f1d375ee1b52aaf8b63159b95b665cce4db1982c6206eff88ac3d08abee651cd2dad4182ee
-  data.tar.gz: de64371b6db6b9deaad66af0296d413b160848508fe36fb8fb70cd8288138d5f7693cd3fcb4022e4ff1aa15964a0ecec06e88042c99b09f3366345aa6289a276
+  metadata.gz: 7576c79cf402f373b7126c97e7af3c70c9b62217c27afe4c7fe0ab25359eb0fa489945bec2e9c6c5b972f4dc4b665d8829e7f60d0707b5540e3506e3ad4ae16e
+  data.tar.gz: 771b11d86f4a5efa8aa13af794b07b031d656ea43f58315b01b5a50fe945495944a4ecb95ff595b690870a7a058956b3abb4412ecae1bceb9ad7f3c1165c2f7e

data/README.md

@@ -4,12 +4,13 @@
 [![Circle CI](https://circleci.com/gh/ericchapman/ruby_wamp_client/tree/master.svg?&style=shield&circle-token=92813c17f9c9510c4c644e41683e7ba2572e0b2a)](https://circleci.com/gh/ericchapman/ruby_wamp_client/tree/master)
 [![Codecov](https://img.shields.io/codecov/c/github/ericchapman/ruby_wamp_client/master.svg)](https://codecov.io/github/ericchapman/ruby_wamp_client)
 
-Client for talking to a WAMP Router.  This is defined at
-
-    https://tools.ietf.org/html/draft-oberstet-hybi-tavendo-wamp-02
+Client for talking to a WAMP Router.  This is defined [here](https://tools.ietf.org/html/draft-oberstet-hybi-tavendo-wamp-02)
 
 ## Revision History
 
+ - v0.0.6:
+   - Added call cancelling
+   - Added call timeout
  - v0.0.5:
    - Fixed issue where excluding the 'authmethods' and 'authid' was setting their values to none rather
      than excluding them.  This was being rejected by some routers
@@ -439,6 +440,7 @@ Options are
 
  - receive_progress [Boolean] - "true" if you support results being able to be sent progressively
  - disclose_me [Boolean] - "true" if the caller would like the callee to know the identity
+ - timeout [Integer] - specifies the number of milliseconds the caller should wait before cancelling the call
 
 #### Errors
 Errors can either be raised OR returned as shown below
@@ -518,6 +520,72 @@ end
 session.register('com.example.procedure', method(:add))
 ```
 
+#### Cancelled Call
+A cancelled call will tell a callee who implements a progressive call to cancel it
+ 
+**Caller**
+
+```ruby
+call = session.call('com.example.procedure', [15], {param: value}, {}) do |result, error, details|
+  # TODO: Do something
+  args = result.args
+  kwargs = result.kwargs
+end
+
+# At some later time...
+
+session.cancel(call, 'skip')  # Options are 'skip', 'kill', or 'killnowait'
+
+# or ...
+
+call.cancel('skip')
+```
+
+**Callee**
+
+(There is probably a better way to do this.  This is a bad example)
+
+```ruby
+@interrupts = {}
+
+def interrupt_handler(request, mode)
+  @interrups[request] = mode
+  
+  # To trigger a custom error, either return something or raise a "CallError"
+  # else the library will raise a standard error for you
+end
+
+def add(args, kwargs, details)
+  defer = WampClient::Defer::ProgressiveCallDefer.new
+  EM.add_timer(2) {  # Something Async
+    if @interrupts[defer.request].nil?
+      defer.progress(WampClient::CallResult.new([1,2,3]))
+    end
+  }
+  EM.add_timer(4) {  # Something Async
+    if @interrupts[defer.request].nil?
+      defer.progress(WampClient::CallResult.new([4,5,6]))
+    end
+  }
+  EM.add_timer(6) {  # Something Async
+    if @interrupts[defer.request].nil?
+      defer.succeed(WampClient::CallResult.new)
+    end
+    @interrupts.delete(request)
+  }
+  defer
+end
+
+session.register('com.example.procedure', method(:add), nil, method(:interrupt_handler))
+```
+
+Notes:
+
+ - Once the response is cancelled, subsequent succeed, progress, or errors are ignored
+   and not sent to the caller
+ - Cancels are only processed by calls that had defers.  If the defer does not exist then
+   the cancel is ignored
+
 ## Contributing
 
 1. Fork it ( https://github.com/ericchapman/ruby_wamp_client )
@@ -526,11 +594,6 @@ session.register('com.example.procedure', method(:add))
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
-### TODOs
-
- - call_timeout
- - call_canceling
-
 ### Testing
 
 The unit tests are run as follows

data/lib/wamp_client/defer.rb

@@ -29,7 +29,7 @@ module WampClient
   module Defer
 
     class CallDefer
-      attr_accessor :request
+      attr_accessor :request, :registration
 
       @on_complete
       def on_complete(&on_complete)

data/lib/wamp_client/session.rb

@@ -36,8 +36,8 @@ module WampClient
       caller: {
           features: {
               caller_identification: true,
-              ##call_timeout: true,
-              ##call_canceling: true,
+              call_timeout: true,
+              call_canceling: true,
               progressive_call_results: true
           }
       },
@@ -48,7 +48,7 @@ module WampClient
               pattern_based_registration: true,
               shared_registration: true,
               ##call_timeout: true,
-              ##call_canceling: true,
+              call_canceling: true,
               progressive_call_results: true,
               registration_revocation: true
           }
@@ -108,12 +108,13 @@ module WampClient
   end
 
   class Registration
-    attr_accessor :procedure, :handler, :options, :session, :id
+    attr_accessor :procedure, :handler, :i_handler, :options, :session, :id
 
-    def initialize(procedure, handler, options, session, id)
+    def initialize(procedure, handler, options, i_handler, session, id)
       self.procedure = procedure
       self.handler = handler
       self.options = options
+      self.i_handler = i_handler
       self.session = session
       self.id = id
     end
@@ -124,6 +125,19 @@ module WampClient
 
   end
 
+  class Call
+    attr_accessor :session, :id
+
+    def initialize(session, id)
+      self.session = session
+      self.id = id
+    end
+
+    def cancel(mode='skip')
+      self.session.cancel(self, mode)
+    end
+
+  end
 
   class Session
     include WampClient::Check
@@ -360,6 +374,8 @@ module WampClient
               self._process_UNREGISTERED(message)
             elsif message.is_a? WampClient::Message::Invocation
               self._process_INVOCATION(message)
+            elsif message.is_a? WampClient::Message::Interrupt
+              self._process_INTERRUPT(message)
             elsif message.is_a? WampClient::Message::Result
               self._process_RESULT(message)
             else
@@ -587,21 +603,23 @@ module WampClient
 
     # Register to a procedure
     # @param procedure [String] The procedure to register for
-    # @param handler [lambda] The handler(args, kwargs, details) when a invocation is received
-    # @param options [Hash] The options for the registration
+    # @param handler [lambda] The handler(args, kwargs, details) when an invocation is received
+    # @param options [Hash, nil] The options for the registration
+    # @param interrupt [lambda] The handler(request, mode) when an interrupt is received
     # @param callback [block] The callback(registration, error, details) called to signal if the registration was a success or not
-    def register(procedure, handler, options={}, &callback)
+    def register(procedure, handler, options=nil, interrupt=nil, &callback)
       unless is_open?
         raise RuntimeError, "Session must be open to call 'register'"
       end
 
+      options ||= {}
+
       self.class.check_uri('procedure', procedure)
-      self.class.check_dict('options', options)
       self.class.check_nil('handler', handler, false)
 
       # Create a new registration request
       request = self._generate_id
-      self._requests[:register][request] = {p: procedure, h: handler, o: options, c: callback}
+      self._requests[:register][request] = {p: procedure, h: handler, i: interrupt, o: options, c: callback}
 
       # Send the message
       register = WampClient::Message::Register.new(request, options, procedure)
@@ -615,7 +633,7 @@ module WampClient
       # Remove the pending subscription, add it to the registered ones, and inform the caller
       r = self._requests[:register].delete(msg.register_request)
       if r
-        n_r = Registration.new(r[:p], r[:h], r[:o], self, msg.registration)
+        n_r = Registration.new(r[:p], r[:h], r[:o], r[:i], self, msg.registration)
         self._registrations[msg.registration] = n_r
 
         details = {}
@@ -646,6 +664,49 @@ module WampClient
 
     end
 
+    # Sends an error back to the caller
+    # @param request[Integer] - The request ID
+    # @param error
+    def _send_INVOCATION_error(request, error, check_defer=false)
+      # Prevent responses for defers that have already completed or had an error
+      if check_defer and not self._defers[request]
+        return
+      end
+
+      if error.nil?
+        error = CallError.new('wamp.error.runtime')
+      elsif not error.is_a?(CallError)
+        error = CallError.new('wamp.error.runtime', [error.to_s])
+      end
+
+      error_msg = WampClient::Message::Error.new(WampClient::Message::Types::INVOCATION, request, {}, error.error, error.args, error.kwargs)
+      self._send_message(error_msg)
+    end
+
+    # Sends a result for the invocation
+    def _send_INVOCATION_result(request, result, options={}, check_defer=false)
+      # Prevent responses for defers that have already completed or had an error
+      if check_defer and not self._defers[request]
+        return
+      end
+
+      if result.nil?
+        result = CallResult.new
+      elsif result.is_a?(CallError)
+        # Do nothing
+      elsif not result.is_a?(CallResult)
+        result = CallResult.new([result])
+      end
+
+      if result.is_a?(CallError)
+        self._send_INVOCATION_error(request, result)
+      else
+        yield_msg = WampClient::Message::Yield.new(request, options, result.args, result.kwargs)
+        self._send_message(yield_msg)
+      end
+    end
+
+
     # Processes and event from the broker
     # @param msg [WampClient::Message::Invocation] An procedure that was called
     def _process_INVOCATION(msg)
@@ -664,73 +725,80 @@ module WampClient
           begin
             value = h.call(args, kwargs, details)
 
-            def send_error(request, error)
-              if error.nil?
-                error = CallError.new('wamp.error.runtime')
-              elsif not error.is_a?(CallError)
-                error = CallError.new('wamp.error.runtime', [error.to_s])
-              end
-
-              error_msg = WampClient::Message::Error.new(WampClient::Message::Types::INVOCATION, request, {}, error.error, error.args, error.kwargs)
-              self._send_message(error_msg)
-            end
-
-            def send_result(request, result, options={})
-              if result.nil?
-                result = CallResult.new
-              elsif result.is_a?(CallError)
-                # Do nothing
-              elsif not result.is_a?(CallResult)
-                result = CallResult.new([result])
-              end
-
-              if result.is_a?(CallError)
-                send_error(request, result)
-              else
-                yield_msg = WampClient::Message::Yield.new(request, options, result.args, result.kwargs)
-                self._send_message(yield_msg)
-              end
-            end
-
             # If a defer was returned, handle accordingly
             if value.is_a? WampClient::Defer::CallDefer
               value.request = request
+              value.registration = msg.registered_registration
 
               # Store the defer
               self._defers[request] = value
 
               # On complete, send the result
               value.on_complete do |defer, result|
-                send_result(defer.request, result)
+                self._send_INVOCATION_result(defer.request, result, {}, true)
                 self._defers.delete(defer.request)
               end
 
               # On error, send the error
               value.on_error do |defer, error|
-                send_error(defer.request, error)
+                self._send_INVOCATION_error(defer.request, error, true)
                 self._defers.delete(defer.request)
               end
 
               # For progressive, return the progress
               if value.is_a? WampClient::Defer::ProgressiveCallDefer
                 value.on_progress do |defer, result|
-                  send_result(defer.request, result, {progress: true})
+                  self._send_INVOCATION_result(defer.request, result, {progress: true}, true)
                 end
               end
 
             # Else it was a normal response
             else
-              send_result(request, value)
+              self._send_INVOCATION_result(request, value)
             end
 
           rescue Exception => error
-            send_error(request, error)
+            self._send_INVOCATION_error(request, error)
           end
 
         end
       end
     end
 
+    # Processes the interrupt
+    # @param msg [WampClient::Message::Interrupt] An interrupt to a procedure
+    def _process_INTERRUPT(msg)
+
+      request = msg.invocation_request
+      mode = msg.options[:mode]
+
+      defer = self._defers[request]
+      if defer
+        r = self._registrations[defer.registration]
+        if r
+          # If it exists, call the interrupt handler to inform it of the interrupt
+          i = r.i_handler
+          error = nil
+          if i
+            begin
+              error = i.call(request, mode)
+            rescue Exception => e
+              error = e
+            end
+          end
+
+          error ||= 'interrupt'
+
+          # Send the error back to the client
+          self._send_INVOCATION_error(request, error, true)
+        end
+
+        # Delete the defer
+        self._defers.delete(request)
+      end
+
+    end
+
     #endregion
 
     #region Unregister Logic
@@ -802,6 +870,7 @@ module WampClient
     # @param kwargs [Hash] The keyword arguments
     # @param options [Hash] The options for the call
     # @param callback [block] The callback(result, error, details) called to signal if the call was a success or not
+    # @return [Call] An object representing the call
     def call(procedure, args=nil, kwargs=nil, options={}, &callback)
       unless is_open?
         raise RuntimeError, "Session must be open to call 'call'"
@@ -817,8 +886,22 @@ module WampClient
       self._requests[:call][request] = {p: procedure, a: args, k: kwargs, o: options, c: callback}
 
       # Send the message
-      call = WampClient::Message::Call.new(request, options, procedure, args, kwargs)
-      self._send_message(call)
+      msg = WampClient::Message::Call.new(request, options, procedure, args, kwargs)
+      self._send_message(msg)
+
+      call = Call.new(self, request)
+
+      # Timeout Logic
+      if options[:timeout] and options[:timeout] > 0
+        self.transport.timer(options[:timeout]) do
+          # Once the timer expires, if the call hasn't completed, cancel it
+          if self._requests[:call][call.id]
+            call.cancel
+          end
+        end
+      end
+
+      call
     end
 
     # Processes the response to a publish request
@@ -862,5 +945,24 @@ module WampClient
 
     #endregion
 
+    #region Cancel Logic
+
+    # Cancels a call
+    # @param call [Call] - The call object
+    # @param mode [String] - The mode of the skip.  Options are 'skip', 'kill', 'killnowait'
+    def cancel(call, mode='skip')
+      unless is_open?
+        raise RuntimeError, "Session must be open to call 'cancel'"
+      end
+
+      self.class.check_nil('call', call, false)
+
+      # Send the message
+      cancel = WampClient::Message::Cancel.new(call.id, { mode: mode })
+      self._send_message(cancel)
+    end
+
+    #endregion
+
   end
 end

data/lib/wamp_client/transport.rb

@@ -106,6 +106,13 @@ module WampClient
         # Implement in subclass
       end
 
+      # Process the callback when the timer expires
+      # @param [Integer] milliseconds - The number
+      # @param [block] callback - The callback that is fired when the timer expires
+      def timer(milliseconds, &callback)
+        # Implement in subclass
+      end
+
     end
 
     # This implementation uses the 'websocket-eventmachine-client' Gem.  This is the default if no transport is included
@@ -151,6 +158,13 @@ module WampClient
         end
       end
 
+      def timer(milliseconds, &callback)
+        delay = (milliseconds.to_f/1000.0).ceil
+        EM.add_timer(delay) {
+          callback.call
+        }
+      end
+
     end
   end
 end

data/lib/wamp_client/version.rb

@@ -26,5 +26,5 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 =end
 
 module WampClient
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/spec/session_spec.rb

@@ -26,6 +26,8 @@ describe WampClient::Session do
       expect(transport.messages[0][0]).to eq(WampClient::Message::Types::HELLO)
       expect(transport.messages[0][1]).to eq('test')  # Realm Test
       expect(transport.messages[0][2][:roles]).not_to be_nil  # Roles exists
+      expect(transport.messages[0][2].key?(:authid)).to eq(false)  # Ensure authid is omitted
+      expect(transport.messages[0][2].key?(:authmethods)).to eq(false)  # Ensure authmethods is ommitted
 
       # Check State
       expect(session.id).to be_nil
@@ -559,6 +561,9 @@ describe WampClient::Session do
 
   describe 'invocation' do
     before(:each) do
+      @mode = nil
+      @request = nil
+
       # Check Exception
       expect { session.register('test.procedure', nil, {test: 1}) }.to raise_exception("Session must be open to call 'register'")
 
@@ -603,6 +608,18 @@ describe WampClient::Session do
       registered = WampClient::Message::Registered.new(request_id, 6789)
       transport.receive_message(registered.payload)
 
+      # Defer Interrupt Register
+      defer_interrupt_handler = lambda do |request, mode|
+        @request = request
+        @mode = mode
+        @response
+      end
+      session.register('test.defer.interrupt.procedure', defer_handler, nil, defer_interrupt_handler)
+
+      request_id = session._requests[:register].keys.first
+      registered = WampClient::Message::Registered.new(request_id, 7896)
+      transport.receive_message(registered.payload)
+
       transport.messages = []
     end
 
@@ -784,6 +801,75 @@ describe WampClient::Session do
       expect(transport.messages[0][6]).to eq({error: true})
 
     end
+
+    context 'cancels' do
+      it 'default response' do
+
+        @response = nil
+
+        @defer = WampClient::Defer::CallDefer.new
+
+        # Generate server event
+        invocation = WampClient::Message::Invocation.new(7890, 7896, {test:1}, [2], {param: 'value'})
+        transport.receive_message(invocation.payload)
+
+        expect(transport.messages.count).to eq(0)
+
+        # Generate the interrupt from the broker/dealer
+        interrupt = WampClient::Message::Interrupt.new(7890, { mode: 'killnowait'})
+        transport.receive_message(interrupt.payload)
+
+        # Check and make sure request and mode were sent
+        expect(@request).to eq(7890)
+        expect(@mode).to eq('killnowait')
+
+        # Check and make sure error message was sent
+        expect(transport.messages.count).to eq(1)
+        expect(transport.messages[0][0]).to eq(WampClient::Message::Types::ERROR)
+        expect(transport.messages[0][1]).to eq(WampClient::Message::Types::INVOCATION)
+        expect(transport.messages[0][2]).to eq(7890)
+        expect(transport.messages[0][3]).to eq({})
+        expect(transport.messages[0][4]).to eq('wamp.error.runtime')
+        expect(transport.messages[0][5]).to eq(['interrupt'])
+
+        # Check and make sure the additional response is ignored
+        @defer.succeed('test')
+        expect(transport.messages.count).to eq(1)
+
+      end
+
+      it 'custom response' do
+
+        @response = 'custom'
+
+        @defer = WampClient::Defer::CallDefer.new
+
+        # Generate server event
+        invocation = WampClient::Message::Invocation.new(7890, 7896, {test:1}, [2], {param: 'value'})
+        transport.receive_message(invocation.payload)
+
+        expect(transport.messages.count).to eq(0)
+
+        # Generate the interrupt from the broker/dealer
+        interrupt = WampClient::Message::Interrupt.new(7890, { mode: 'kill'})
+        transport.receive_message(interrupt.payload)
+
+        # Check and make sure request and mode were sent
+        expect(@request).to eq(7890)
+        expect(@mode).to eq('kill')
+
+        # Check and make sure error message was sent
+        expect(transport.messages.count).to eq(1)
+        expect(transport.messages[0][0]).to eq(WampClient::Message::Types::ERROR)
+        expect(transport.messages[0][1]).to eq(WampClient::Message::Types::INVOCATION)
+        expect(transport.messages[0][2]).to eq(7890)
+        expect(transport.messages[0][3]).to eq({})
+        expect(transport.messages[0][4]).to eq('wamp.error.runtime')
+        expect(transport.messages[0][5]).to eq(['custom'])
+
+      end
+
+    end
   end
 
   describe 'unregister' do
@@ -992,6 +1078,73 @@ describe WampClient::Session do
 
     end
 
+    it 'cancels calling a procedure' do
+
+      count = 0
+      call = session.call('test.procedure', nil, nil, {acknowledge: true}) do |result, error, details|
+        count += 1
+
+        expect(result).to be_nil
+        expect(error[:error]).to eq('this.cancelled')
+        expect(details).to eq({fail: true, procedure: 'test.procedure', type: 'call'})
+      end
+
+      @request_id = session._requests[:call].keys.first
+
+      expect(count).to eq(0)
+
+      # Call Cancel
+      call.cancel('kill')
+
+      # Check transport
+      expect(transport.messages.count).to eq(2)
+      expect(transport.messages[1][0]).to eq(WampClient::Message::Types::CANCEL)
+      expect(transport.messages[1][1]).to eq(call.id)
+      expect(transport.messages[1][2]).to eq({mode: 'kill'})
+
+      # Generate Server Response
+      error = WampClient::Message::Error.new(WampClient::Message::Types::CALL,
+                                             @request_id, {fail: true}, 'this.cancelled')
+      transport.receive_message(error.payload)
+
+      expect(count).to eq(1)
+
+      # Check the request dictionary
+      expect(session._requests[:call].count).to eq(0)
+
+    end
+
+    context 'timeout' do
+      it 'does not cancel a call if no timeout specified' do
+        @defer = WampClient::Defer::ProgressiveCallDefer.new
+
+        count = 0
+        session.call('test.procedure', nil, nil) do |result, error, details|
+          count += 1
+        end
+
+        expect(transport.timer_callback).to be_nil
+        expect(transport.messages.count).to eq(1)
+      end
+
+      it 'does cancel a call if a timeout is specified' do
+        @defer = WampClient::Defer::ProgressiveCallDefer.new
+
+        count = 0
+        call = session.call('test.procedure', nil, nil, {timeout: 1000}) do |result, error, details|
+          count += 1
+        end
+
+        expect(transport.timer_callback).not_to be_nil
+        transport.timer_callback.call
+
+        expect(transport.messages.count).to eq(2)
+
+        expect(transport.messages[1][0]).to eq(WampClient::Message::Types::CANCEL)
+        expect(transport.messages[1][1]).to eq(call.id)
+        expect(transport.messages[1][2]).to eq({mode: 'skip'})
+      end
+    end
   end
 
   describe 'progressive_call_results' do
@@ -1004,7 +1157,7 @@ describe WampClient::Session do
       transport.messages = []
     end
 
-    it 'caller ignores (should only get the first response' do
+    it 'caller ignores (should only get the first response because receive_progress is false)' do
 
       results = []
       session.call('test.procedure', [], {}, {}) do |result, error, details|
@@ -1162,6 +1315,56 @@ describe WampClient::Session do
 
     end
 
+    it 'callee error support' do
+
+      # Defer Register
+      @defer = WampClient::Defer::ProgressiveCallDefer.new
+      defer_handler = lambda do |args, kwargs, details|
+        @defer
+      end
+      session.register('test.defer.procedure', defer_handler)
+
+      request_id = session._requests[:register].keys.first
+      registered = WampClient::Message::Registered.new(request_id, 4567)
+      transport.receive_message(registered.payload)
+
+      transport.messages = []
+
+      # Generate server event
+      invocation = WampClient::Message::Invocation.new(7890, 4567, {test:1}, [2], {param: 'value'})
+      transport.receive_message(invocation.payload)
+
+      expect(transport.messages.count).to eq(0)
+      expect(session._defers.count).to eq(1)
+
+      @defer.progress(WampClient::CallResult.new(['test1']))
+      expect(session._defers.count).to eq(1)
+      @defer.progress(WampClient::CallResult.new(['test2']))
+      expect(session._defers.count).to eq(1)
+      @defer.fail(WampClient::CallError.new('test.error'))
+      expect(session._defers.count).to eq(0)
+
+      expect(transport.messages.count).to eq(3)
+
+      # Check and make sure yield message was sent
+      expect(transport.messages[0][0]).to eq(WampClient::Message::Types::YIELD)
+      expect(transport.messages[0][1]).to eq(7890)
+      expect(transport.messages[0][2]).to eq({progress: true})
+      expect(transport.messages[0][3]).to eq(['test1'])
+
+      expect(transport.messages[1][0]).to eq(WampClient::Message::Types::YIELD)
+      expect(transport.messages[1][1]).to eq(7890)
+      expect(transport.messages[1][2]).to eq({progress: true})
+      expect(transport.messages[1][3]).to eq(['test2'])
+
+      expect(transport.messages[2][0]).to eq(WampClient::Message::Types::ERROR)
+      expect(transport.messages[2][1]).to eq(WampClient::Message::Types::INVOCATION)
+      expect(transport.messages[2][2]).to eq(7890)
+      expect(transport.messages[2][3]).to eq({})
+      expect(transport.messages[2][4]).to eq('test.error')
+
+    end
+
   end
 
   describe 'auth' do

data/spec/spec_helper.rb

@@ -14,7 +14,7 @@ module SpecHelper
 
   class TestTransport < WampClient::Transport::Base
 
-    attr_accessor :messages
+    attr_accessor :messages, :timer_callback
 
     def initialize(options)
       super(options)
@@ -40,6 +40,10 @@ module SpecHelper
       @on_message.call(deserialize) unless @on_message.nil?
     end
 
+    def timer(milliseconds, &callback)
+      self.timer_callback = callback
+    end
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wamp_client
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Eric Chapman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-05 00:00:00.000000000 Z
+date: 2016-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler