ably-rest 0.8.3 → 0.8.5

data/lib/submodules/ably-ruby/lib/ably/realtime/connection/connection_state_machine.rb

@@ -41,23 +41,25 @@ module Ably::Realtime
       end
 
       before_transition(to: [:connected]) do |connection, current_transition|
-        connection.manager.connected current_transition.metadata
+        connection.manager.connected current_transition.metadata.protocol_message
       end
 
       after_transition(to: [:connected]) do |connection, current_transition|
-        protocol_message = current_transition.metadata
-        if is_error_type?(protocol_message.error)
-          connection.logger.warn "ConnectionManager: Connected with error - #{protocol_message.error.message}"
-          connection.emit :error, protocol_message.error
+        error = current_transition.metadata.reason
+        if is_error_type?(error)
+          connection.logger.warn "ConnectionManager: Connected with error - #{error.message}"
+          connection.emit :error, error
         end
       end
 
       after_transition(to: [:disconnected, :suspended], from: [:connecting]) do |connection, current_transition|
-        connection.manager.respond_to_transport_disconnected_when_connecting current_transition
+        err = error_from_state_change(current_transition)
+        connection.manager.respond_to_transport_disconnected_when_connecting err
       end
 
-      after_transition(to: [:disconnected], from: [:connected]) do |connection, current_transition|
-        connection.manager.respond_to_transport_disconnected_whilst_connected current_transition
+      after_transition(to: [:disconnected, :suspended], from: [:connected]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.manager.respond_to_transport_disconnected_whilst_connected err
       end
 
       after_transition(to: [:disconnected, :suspended]) do |connection|
@@ -65,7 +67,8 @@ module Ably::Realtime
       end
 
       before_transition(to: [:failed]) do |connection, current_transition|
-        connection.manager.fail current_transition.metadata
+        err = error_from_state_change(current_transition)
+        connection.manager.fail err
       end
 
       after_transition(to: [:closing], from: [:initialized, :disconnected, :suspended]) do |connection|
@@ -82,24 +85,29 @@ module Ably::Realtime
 
       # Transitions responsible for updating connection#error_reason
       before_transition(to: [:disconnected, :suspended, :failed]) do |connection, current_transition|
-        connection.set_failed_connection_error_reason current_transition.metadata
+        err = error_from_state_change(current_transition)
+        connection.set_failed_connection_error_reason err
       end
 
       before_transition(to: [:connected, :closed]) do |connection, current_transition|
-        error = if current_transition.metadata.kind_of?(Ably::Models::ProtocolMessage)
-          current_transition.metadata.error
-        else
-          current_transition.metadata
-        end
+        err = error_from_state_change(current_transition)
 
-        if is_error_type?(error)
-          connection.set_failed_connection_error_reason error
+        if err
+          connection.set_failed_connection_error_reason err
         else
           # Connected & Closed are "healthy" final states so reset the error reason
           connection.clear_error_reason
         end
       end
 
+      def self.error_from_state_change(current_transition)
+        # ConnectionStateChange object is always passed in current_transition metadata object
+        connection_state_change = current_transition.metadata
+        # Reason attribute contains errors
+        err = connection_state_change && connection_state_change.reason
+        err if is_error_type?(err)
+      end
+
       private
       def connection
         object

data/lib/submodules/ably-ruby/lib/ably/realtime/presence.rb

@@ -405,7 +405,7 @@ module Ably::Realtime
           deferrable_succeed deferrable, &success_block
         end
 
-        protocol_message.errback do |message, error|
+        protocol_message.errback do |error|
           change_state failed_state, error if failed_state
           deferrable_fail deferrable, error
         end
@@ -419,8 +419,8 @@ module Ably::Realtime
     end
 
     def deferrable_fail(deferrable, *args, &block)
-      safe_yield block, self, *args if block_given?
-      EventMachine.next_tick { deferrable.fail self, *args } # allow errback to be added to the returned Deferrable
+      safe_yield block, *args if block_given?
+      EventMachine.next_tick { deferrable.fail *args } # allow errback to be added to the returned Deferrable
       deferrable
     end
 
@@ -431,7 +431,7 @@ module Ably::Realtime
       ensure_channel_attached(deferrable) do
         send_presence_protocol_message(action, client_id, options).tap do |protocol_message|
           protocol_message.callback { |message| deferrable_succeed deferrable, &success_block }
-          protocol_message.errback  { |message, error| deferrable_fail deferrable, error }
+          protocol_message.errback  { |error| deferrable_fail deferrable, error }
         end
       end
     end

data/lib/submodules/ably-ruby/lib/ably/rest/channel.rb

@@ -34,6 +34,7 @@ module Ably
       #
       # @param name [String, Array<Ably::Models::Message|Hash>, nil]   The event name of the message to publish, or an Array of [Ably::Model::Message] objects or [Hash] objects with +:name+ and +:data+ pairs
       # @param data [String, ByteArray, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument
+      # @param attributes [Hash, nil]   Optional additional message attributes such as :client_id or :connection_id, applied when name attribute is nil or a string
       # @return [Boolean]  true if the message was published, otherwise false
       #
       # @example
@@ -54,13 +55,13 @@ module Ably
       #   ]
       #   channel.publish messages
       #
-      def publish(name, data = nil)
+      def publish(name, data = nil, attributes = {})
         messages = if name.kind_of?(Enumerable)
           name
         else
           ensure_utf_8 :name, name, allow_nil: true
           ensure_supported_payload data
-          [{ name: name, data: data }]
+          [{ name: name, data: data }.merge(attributes)]
         end
 
         payload = messages.map do |message|

data/lib/submodules/ably-ruby/lib/ably/rest/client.rb

@@ -144,7 +144,7 @@ module Ably
 
         token_params = options.delete(:token_params) || {}
         @options  = options
-        @auth     = Auth.new(self, options, token_params)
+        @auth     = Auth.new(self, token_params, options)
         @channels = Ably::Rest::Channels.new(self)
         @encoders = []
 
@@ -358,7 +358,7 @@ module Ably
         yield
       rescue Ably::Exceptions::TokenExpired => e
         if auth.token_renewable?
-          auth.authorise force: true
+          auth.authorise({}, force: true)
           yield
         else
           raise e

data/lib/submodules/ably-ruby/lib/ably/util/crypto.rb

@@ -37,6 +37,21 @@ module Ably::Util
       @options = DEFAULTS.merge(options).freeze
     end
 
+    # Obtain a default CipherParams. This uses default algorithm, mode and
+    # padding and key length. A key and IV are generated using the default
+    # system SecureRandom; the key may be obtained from the returned CipherParams
+    # for out-of-band distribution to other clients.
+    #
+    # @return [Hash]   CipherParam options Hash with attributes :key, :algorithn, :mode, :key_length
+    #
+    def self.get_default_params(key = nil)
+      params = DEFAULTS.merge(key: key)
+      params[:key_length] = key.unpack('b*').first.length if params[:key]
+      cipher_type = "#{params[:algorithm]}-#{params[:key_length]}-#{params[:mode]}"
+      params[:key] = OpenSSL::Cipher.new(cipher_type.upcase).random_key unless params[:key]
+      params
+    end
+
     # Encrypt payload using configured Cipher
     #
     # @param [String] payload           the payload to be encrypted

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.3'
+  VERSION = '0.8.5'
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/auth_spec.rb

@@ -8,7 +8,7 @@ describe Ably::Realtime::Auth, :event_machine do
   vary_by_protocol do
     let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options)  { default_options }
-    let(:client)          { Ably::Realtime::Client.new(client_options) }
+    let(:client)          { auto_close Ably::Realtime::Client.new(client_options) }
     let(:auth)            { client.auth }
 
     context 'with basic auth' do
@@ -101,7 +101,7 @@ describe Ably::Realtime::Auth, :event_machine do
         let(:auth_params) { { :body => random_str } }
 
         it 'contains the configured auth options' do
-          auth.authorise(auth_url: auth_url, auth_params: auth_params) do
+          auth.authorise({}, auth_url: auth_url, auth_params: auth_params) do
             expect(auth.options[:auth_url]).to eql(auth_url)
             stop_reactor
           end
@@ -112,7 +112,7 @@ describe Ably::Realtime::Auth, :event_machine do
         let(:custom_ttl) { 33 }
 
         it 'contains the configured auth options' do
-          auth.authorise({}, ttl: custom_ttl) do
+          auth.authorise(ttl: custom_ttl) do
             expect(auth.token_params[:ttl]).to eql(custom_ttl)
             stop_reactor
           end
@@ -144,7 +144,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#create_token_request' do
         it 'returns a token request asynchronously' do
-          auth.create_token_request({}, { ttl: custom_ttl }) do |token_request|
+          auth.create_token_request(ttl: custom_ttl) do |token_request|
             expect(token_request).to be_a(Ably::Models::TokenRequest)
             expect(token_request.ttl).to eql(custom_ttl)
             stop_reactor
@@ -154,7 +154,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#create_token_request_async' do
         it 'returns a token request synchronously' do
-          auth.create_token_request_sync(token_params: { ttl: custom_ttl }).tap do |token_request|
+          auth.create_token_request_sync(ttl: custom_ttl).tap do |token_request|
             expect(token_request).to be_a(Ably::Models::TokenRequest)
             expect(token_request.ttl).to eql(custom_ttl)
             stop_reactor
@@ -164,7 +164,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#request_token' do
         it 'returns a token asynchronously' do
-          auth.request_token({ client_id: custom_client_id }, ttl: custom_ttl) do |token_details|
+          auth.request_token(client_id: custom_client_id, ttl: custom_ttl) do |token_details|
             expect(token_details).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
@@ -175,7 +175,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#request_token_async' do
         it 'returns a token synchronously' do
-          auth.request_token_sync(client_id: custom_client_id, token_params: { ttl: custom_ttl }).tap do |token_details|
+          auth.request_token_sync(ttl: custom_ttl, client_id: custom_client_id).tap do |token_details|
             expect(token_details).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
@@ -186,7 +186,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#authorise' do
         it 'returns a token asynchronously' do
-          auth.authorise({ client_id: custom_client_id }, ttl: custom_ttl) do |token_details|
+          auth.authorise(ttl: custom_ttl, client_id: custom_client_id) do |token_details|
             expect(token_details).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
@@ -197,7 +197,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#authorise_async' do
         it 'returns a token synchronously' do
-          auth.authorise_sync(client_id: custom_client_id, token_params: { ttl: custom_ttl }).tap do |token_details|
+          auth.authorise_sync(ttl: custom_ttl, client_id: custom_client_id).tap do |token_details|
             expect(auth.authorise_sync).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_history_spec.rb

@@ -5,11 +5,11 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
   vary_by_protocol do
     let(:default_options) { options.merge(key: api_key, environment: environment, protocol: protocol) }
 
-    let(:client)       { Ably::Realtime::Client.new(default_options) }
+    let(:client)       { auto_close Ably::Realtime::Client.new(default_options) }
     let(:channel)      { client.channel(channel_name) }
     let(:rest_channel) { client.rest_client.channel(channel_name) }
 
-    let(:client2)      { Ably::Realtime::Client.new(default_options) }
+    let(:client2)      { auto_close Ably::Realtime::Client.new(default_options) }
     let(:channel2)     { client2.channel(channel_name) }
 
     let(:channel_name) { "persisted:#{random_str(2)}" }

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_spec.rb

@@ -6,7 +6,7 @@ describe Ably::Realtime::Channel, :event_machine do
     let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options)  { default_options }
 
-    let(:client)       { Ably::Realtime::Client.new(client_options) }
+    let(:client)       { auto_close Ably::Realtime::Client.new(client_options) }
     let(:channel_name) { random_str }
     let(:payload)      { random_str }
     let(:channel)      { client.channel(channel_name) }
@@ -15,7 +15,7 @@ describe Ably::Realtime::Channel, :event_machine do
     describe 'initialization' do
       context 'with :auto_connect option set to false on connection' do
         let(:client) do
-          Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
+          auto_close Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
         end
 
         it 'remains initialized when accessing a channel' do
@@ -80,7 +80,7 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       it 'calls the SafeDeferrable callback on success' do
-        channel.attach.callback do |channel|
+        channel.attach.callback do
           expect(channel).to be_a(Ably::Realtime::Channel)
           expect(channel.state).to eq(:attached)
           stop_reactor
@@ -92,7 +92,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'reattaches' do
           channel.attach do
-            channel.transition_state_machine :failed, RuntimeError.new
+            channel.transition_state_machine :failed, reason: RuntimeError.new
             expect(channel).to be_failed
             channel.attach do
               expect(channel).to be_attached
@@ -131,7 +131,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'attaches all channels', em_timeout: 15 do
           connection_count.times.map do
-            Ably::Realtime::Client.new(default_options)
+            auto_close Ably::Realtime::Client.new(default_options)
           end.each do |client|
             channel_count.times.map do |index|
               client.channel("channel-#{index}").attach do
@@ -148,21 +148,21 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'failure as a result of insufficient key permissions' do
         let(:restricted_client) do
-          Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
+          auto_close Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
         end
         let(:restricted_channel) { restricted_client.channel("cannot_subscribe") }
 
         it 'emits failed event' do
           restricted_channel.attach
-          restricted_channel.on(:failed) do |error|
+          restricted_channel.on(:failed) do |connection_state|
             expect(restricted_channel.state).to eq(:failed)
-            expect(error.status).to eq(401)
+            expect(connection_state.reason.status).to eq(401)
             stop_reactor
           end
         end
 
         it 'calls the errback of the returned Deferrable' do
-          restricted_channel.attach.errback do |channel, error|
+          restricted_channel.attach.errback do |error|
             expect(restricted_channel.state).to eq(:failed)
             expect(error.status).to eq(401)
             stop_reactor
@@ -192,7 +192,7 @@ describe Ably::Realtime::Channel, :event_machine do
             restricted_channel.once(:failed) do
               restricted_client.close do
                 # A direct call to #authorise is synchronous
-                restricted_client.auth.authorise(key: api_key)
+                restricted_client.auth.authorise({}, key: api_key)
 
                 restricted_client.connect do
                   restricted_channel.once(:attached) do
@@ -220,9 +220,10 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       it 'detaches from a channel and calls the provided block' do
-        channel.attach do |chan|
-          chan.detach do |detached_chan|
-            expect(detached_chan.state).to eq(:detached)
+        channel.attach do
+          expect(channel.state).to eq(:attached)
+          channel.detach do
+            expect(channel.state).to eq(:detached)
             stop_reactor
           end
         end
@@ -249,7 +250,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       it 'calls the Deferrable callback on success' do
         channel.attach do
-          channel.detach.callback do |channel|
+          channel.detach.callback do
             expect(channel).to be_a(Ably::Realtime::Channel)
             expect(channel.state).to eq(:detached)
             stop_reactor
@@ -262,7 +263,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'raises an exception' do
           channel.attach do
-            channel.transition_state_machine :failed, RuntimeError.new
+            channel.transition_state_machine :failed, reason: RuntimeError.new
             expect(channel).to be_failed
             expect { channel.detach }.to raise_error Ably::Exceptions::InvalidStateChange
             stop_reactor
@@ -433,6 +434,19 @@ describe Ably::Realtime::Channel, :event_machine do
             end
           end
         end
+
+        context 'and additional attributes' do
+          let(:client_id) { random_str }
+
+          it 'publishes the message with the attributes and return true indicating success' do
+            channel.publish(name, data, client_id: client_id) do
+              channel.history do |page|
+                expect(page.items.first.client_id).to eql(client_id)
+                stop_reactor
+              end
+            end
+          end
+        end
       end
 
       context 'with an array of Hash objects with :name and :data attributes' do
@@ -550,7 +564,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'publishes all messages, all success callbacks are called, and a history request confirms all messages were published' do
           connection_count.times.map do
-            Ably::Realtime::Client.new(client_options)
+            auto_close Ably::Realtime::Client.new(client_options)
           end.each do |client|
             channel = client.channels.get(channel_name)
             messages.each do |message|
@@ -666,7 +680,8 @@ describe Ably::Realtime::Channel, :event_machine do
         context 'an :attached channel' do
           it 'transitions state to :failed' do
             channel.attach do
-              channel.on(:failed) do |error|
+              channel.on(:failed) do |connection_state_change|
+                error = connection_state_change.reason
                 expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
                 expect(error.code).to eql(80002)
                 stop_reactor
@@ -688,7 +703,8 @@ describe Ably::Realtime::Channel, :event_machine do
 
           it 'updates the channel error_reason' do
             channel.attach do
-              channel.on(:failed) do |error|
+              channel.on(:failed) do |connection_state_change|
+                error = connection_state_change.reason
                 expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
                 expect(error.code).to eql(80002)
                 stop_reactor
@@ -734,7 +750,7 @@ describe Ably::Realtime::Channel, :event_machine do
                 fake_error connection_error
               end
 
-              channel.transition_state_machine :failed, original_error
+              channel.transition_state_machine :failed, reason: original_error
             end
           end
         end
@@ -783,8 +799,8 @@ describe Ably::Realtime::Channel, :event_machine do
         end
 
         context 'a :failed channel' do
-          let(:original_error) { RuntimeError.new }
           let(:client_options)   { default_options.merge(log_level: :fatal) }
+          let(:original_error) { Ably::Models::ErrorInfo.new(message: 'Error') }
 
           it 'remains in the :failed state and retains the error_reason' do
             channel.attach do
@@ -801,7 +817,7 @@ describe Ably::Realtime::Channel, :event_machine do
                 client.connection.close
               end
 
-              channel.transition_state_machine :failed, original_error
+              channel.transition_state_machine :failed, reason: original_error
             end
           end
         end
@@ -830,6 +846,75 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
       end
+
+      context ':suspended' do
+        context 'an :attached channel' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+
+          it 'transitions state to :detached' do
+            channel.attach do
+              channel.on(:detached) do
+                stop_reactor
+              end
+              client.connection.transition_state_machine :suspended
+            end
+          end
+        end
+
+        context 'a :detached channel' do
+          it 'remains in the :detached state' do
+            channel.attach do
+              channel.detach do
+                channel.on(:detached) { raise 'Detached state should not have been reached' }
+                channel.on(:error)    { raise 'Error should not have been emitted' }
+
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_detached
+                  stop_reactor
+                end
+
+                client.connection.transition_state_machine :suspended
+              end
+            end
+          end
+        end
+
+        context 'a :failed channel' do
+          let(:original_error) { RuntimeError.new }
+          let(:client_options)   { default_options.merge(log_level: :fatal) }
+
+          it 'remains in the :failed state and retains the error_reason' do
+            channel.attach do
+              channel.once(:error) do
+                channel.on(:detached) { raise 'Detached state should not have been reached' }
+                channel.on(:error)    { raise 'Error should not have been emitted' }
+
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_failed
+                  expect(channel.error_reason).to eql(original_error)
+                  stop_reactor
+                end
+
+                client.connection.transition_state_machine :suspended
+              end
+
+              channel.transition_state_machine :failed, reason: original_error
+            end
+          end
+        end
+
+        context 'a channel ATTACH request when connection SUSPENDED' do
+          it 'raises an exception' do
+            client.connect do
+              client.connection.once(:suspended) do
+                expect { channel.attach }.to raise_error Ably::Exceptions::InvalidStateChange
+                stop_reactor
+              end
+              client.connection.transition_state_machine :suspended
+            end
+          end
+        end
+      end
     end
 
     describe '#presence' do
@@ -838,5 +923,67 @@ describe Ably::Realtime::Channel, :event_machine do
         stop_reactor
       end
     end
+
+    context 'channel state change' do
+      it 'emits a ChannelStateChange object' do
+        channel.on(:attached) do |channel_state_change|
+          expect(channel_state_change).to be_a(Ably::Models::ChannelStateChange)
+          stop_reactor
+        end
+        channel.attach
+      end
+
+      context 'ChannelStateChange object' do
+        it 'has current state' do
+          channel.on(:attached) do |channel_state_change|
+            expect(channel_state_change.current).to eq(:attached)
+            stop_reactor
+          end
+          channel.attach
+        end
+
+        it 'has a previous state' do
+          channel.on(:attached) do |channel_state_change|
+            expect(channel_state_change.previous).to eq(:attaching)
+            stop_reactor
+          end
+          channel.attach
+        end
+
+        it 'contains a private API protocol_message attribute that is used for special state change events', :api_private do
+          channel.on(:attached) do |channel_state_change|
+            expect(channel_state_change.protocol_message).to be_a(Ably::Models::ProtocolMessage)
+            expect(channel_state_change.reason).to be_nil
+            stop_reactor
+          end
+          channel.attach
+        end
+
+        it 'has an empty reason when there is no error' do
+          channel.on(:detached) do |channel_state_change|
+            expect(channel_state_change.reason).to be_nil
+            stop_reactor
+          end
+          channel.attach do
+            channel.detach
+          end
+        end
+
+        context 'on failure' do
+          let(:client_options) { default_options.merge(log_level: :none) }
+
+          it 'has a reason Error object when there is an error on the channel' do
+            channel.on(:failed) do |channel_state_change|
+              expect(channel_state_change.reason).to be_a(Ably::Exceptions::BaseAblyException)
+              stop_reactor
+            end
+            channel.attach do
+              error = Ably::Exceptions::ConnectionFailed.new('forced failure', 500, 50000)
+              client.connection.manager.error_received_from_server error
+            end
+          end
+        end
+      end
+    end
   end
 end