ably 1.1.4.rc → 1.1.7

data/lib/ably/realtime/presence.rb

@@ -278,28 +278,14 @@ module Ably::Realtime
 
     # Return the presence messages history for the channel
     #
-    # Once attached to a channel, you can retrieve presence message history on the channel before the
-    # channel was attached with the option <tt>until_attach: true</tt>.  This is very useful for
-    # developers who wish to capture new presence events as well as retrieve historical presence state with
-    # the guarantee that no presence history has been missed.
-    #
     # @param (see Ably::Rest::Presence#history)
     # @option options (see Ably::Rest::Presence#history)
-    # @option options [Boolean]  :until_attach  When true, request for history will be limited only to messages published before the associated channel was attached. The associated channel must be attached.
     #
     # @yield [Ably::Models::PaginatedResult<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResult page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResult#items #items}.
     #
     # @return [Ably::Util::SafeDeferrable]
     #
     def history(options = {}, &callback)
-      if options.delete(:until_attach)
-        unless channel.attached?
-          error = Ably::Exceptions::InvalidRequest.new('option :until_attach is invalid as the channel is not attached')
-          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
-        end
-        options[:from_serial] = channel.attached_serial
-      end
-
       async_wrap(callback) do
         rest_presence.history(options.merge(async_blocking_operations: true))
       end

data/lib/ably/rest/channel.rb

@@ -23,6 +23,7 @@ module Ably
       attr_reader :push
 
       IDEMPOTENT_LIBRARY_GENERATED_ID_LENGTH = 9 # See spec RSL1k1
+      MAX_MESSAGE_SIZE = 65536 # See spec TO3l8
 
       # Initialize a new Channel object
       #
@@ -52,8 +53,8 @@ module Ably
       #
       #   # Publish an array of message Hashes
       #   messages = [
-      #     { name: 'click', { x: 1, y: 2 } },
-      #     { name: 'click', { x: 2, y: 3 } }
+      #     { name: 'click', data: { x: 1, y: 2 } },
+      #     { name: 'click', data: { x: 2, y: 3 } }
       #   ]
       #   channel.publish messages
       #
@@ -85,7 +86,13 @@ module Ably
           [[{ name: first, data: second }.merge(third)], nil]
         end
 
-        payload = messages.each_with_index.map do |message, index|
+        messages.map! { |message| Ably::Models::Message(message.dup) }
+
+        if messages.sum(&:size) > Ably::Rest::Channel::MAX_MESSAGE_SIZE
+          raise Ably::Exceptions::MaxMessageSizeExceeded.new("Maximum message size exceeded #{Ably::Rest::Channel::MAX_MESSAGE_SIZE}.")
+        end
+
+        payload = messages.map do |message|
           Ably::Models::Message(message.dup).tap do |msg|
             msg.encode client.encoders, options
 

data/lib/ably/rest/client.rb

@@ -25,6 +25,8 @@ module Ably
       # Default Ably domain for REST
       DOMAIN = 'rest.ably.io'
 
+      MAX_FRAME_SIZE = 524288
+
       # Configuration for HTTP timeouts and HTTP request reattempts to fallback hosts
       HTTP_DEFAULTS = {
         open_timeout:       4,
@@ -52,6 +54,10 @@ module Ably
       # @return [Symbol]
       attr_reader :protocol
 
+      # Client agent i.e. `example-gem/1.2.0 ably-ruby/1.1.5 ruby/1.9.3`
+      # @return [String]
+      attr_reader :agent
+
       # {Ably::Auth} authentication object configured for this connection
       # @return [Ably::Auth]
       attr_reader :auth
@@ -168,6 +174,7 @@ module Ably
           end
         end
 
+        @agent               = options.delete(:agent) || Ably::AGENT
         @realtime_client     = options.delete(:realtime_client)
         @tls                 = options.delete(:tls) == false ? false : true
         @environment         = options.delete(:environment) # nil is production
@@ -184,16 +191,18 @@ module Ably
         @idempotent_rest_publishing = options.delete(:idempotent_rest_publishing) || Ably.major_minor_version_numeric > 1.1
 
 
-        if options[:fallback_hosts_use_default] && options[:fallback_jhosts]
-          raise ArgumentError, "fallback_hosts_use_default cannot be set to trye when fallback_jhosts is also provided"
+        if options[:fallback_hosts_use_default] && options[:fallback_hosts]
+          raise ArgumentError, "fallback_hosts_use_default cannot be set to try when fallback_hosts is also provided"
         end
         @fallback_hosts = case
         when options.delete(:fallback_hosts_use_default)
           Ably::FALLBACK_HOSTS
         when options_fallback_hosts = options.delete(:fallback_hosts)
           options_fallback_hosts
-        when environment || custom_host || options[:realtime_host] || custom_port || custom_tls_port
+        when custom_host || options[:realtime_host] || custom_port || custom_tls_port
           []
+        when environment
+          CUSTOM_ENVIRONMENT_FALLBACKS_SUFFIXES.map { |host| "#{environment}#{host}" }
         else
           Ably::FALLBACK_HOSTS
         end
@@ -348,14 +357,17 @@ module Ably
       #
       # @return [Ably::Models::HttpPaginatedResponse<>]
       def request(method, path, params = {}, body = nil, headers = {}, options = {})
-        raise "Method #{method.to_s.upcase} not supported" unless [:get, :put, :post].include?(method.to_sym)
+        raise "Method #{method.to_s.upcase} not supported" unless %i(get put patch post delete).include?(method.to_sym)
 
         response = case method.to_sym
-        when :get
+        when :get, :delete
           reauthorize_on_authorization_failure do
             send_request(method, path, params, headers: headers)
           end
-        when :post
+        when :post, :patch, :put
+          if body.to_json.bytesize > MAX_FRAME_SIZE
+            raise Ably::Exceptions::MaxFrameSizeExceeded.new("Maximum frame size exceeded #{MAX_FRAME_SIZE} bytes.")
+          end
           path_with_params = Addressable::URI.new
           path_with_params.query_values = params || {}
           query = path_with_params.query
@@ -471,16 +483,6 @@ module Ably
         end
       end
 
-      # Library Ably version user agent
-      # @api private
-      def lib_version_id
-        @lib_version_id ||= [
-          'ruby',
-          Ably.lib_variant,
-          Ably::VERSION
-        ].compact.join('-')
-      end
-
       # Allowable duration for an external auth request
       # For REST client this defaults to request_timeout
       # For Realtime clients this defaults to 250ms less than the realtime_request_timeout
@@ -576,10 +578,9 @@ module Ably
             end
             unless options[:send_auth_header] == false
               request.headers[:authorization] = auth.auth_header
-              if options[:headers]
-                options[:headers].map do |key, val|
-                  request.headers[key] = val
-                end
+
+              options[:headers].to_h.merge(auth.extra_auth_headers).map do |key, val|
+                request.headers[key] = val
               end
             end
           end.tap do
@@ -662,7 +663,7 @@ module Ably
             accept:             mime_type,
             user_agent:         user_agent,
             'X-Ably-Version' => Ably::PROTOCOL_VERSION,
-            'X-Ably-Lib'     => lib_version_id
+            'Ably-Agent'     => agent
           },
           request: {
             open_timeout: http_defaults.fetch(:open_timeout),

data/lib/ably/version.rb

@@ -1,19 +1,7 @@
 module Ably
-  VERSION = '1.1.4.rc'
+  VERSION = '1.1.7'
   PROTOCOL_VERSION = '1.1'
 
-  # Allow a variant to be configured for all instances of this client library
-  # such as ruby-rest-[VERSION]
-
-  # @api private
-  def self.lib_variant=(variant)
-    @lib_variant = variant
-  end
-
-  def self.lib_variant
-    @lib_variant
-  end
-
   # @api private
   def self.major_minor_version_numeric
     VERSION.gsub(/\.\d+$/, '').to_f

data/spec/acceptance/realtime/auth_spec.rb

@@ -1237,7 +1237,7 @@ describe Ably::Realtime::Auth, :event_machine do
         let(:basic_capability) { JSON.dump(channel_name => ['subscribe'], channel_with_publish_permissions => ['publish']) }
         let(:auth_callback) do
           lambda do |token_params|
-            Faraday.get("#{auth_url}?keyName=#{key_name}&keySecret=#{key_secret}&capability=#{URI.escape(basic_capability)}").body
+            Faraday.get("#{auth_url}?keyName=#{key_name}&keySecret=#{key_secret}&capability=#{URI::Parser.new.escape(basic_capability)}").body
           end
         end
         let(:client_options) { default_options.merge(auth_callback: auth_callback, log_level: :error) }

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -183,6 +183,31 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
         end
       end
 
+      context 'when channel receives update event after an attachment' do
+        before do
+          channel.on(:attached) do
+            channel.publish(event, message_after_attach) do
+              subsequent_serial = channel.properties.attach_serial.dup.tap { |serial| serial[-1] = '1' }
+              attached_message = Ably::Models::ProtocolMessage.new(action: 11, channel: channel_name, flags: 0, channel_serial: subsequent_serial)
+              client.connection.__incoming_protocol_msgbus__.publish :protocol_message, attached_message
+            end
+          end
+        end
+
+        it 'updates attach_serial' do
+          rest_channel.publish event, message_before_attach
+
+          channel.on(:update) do
+            channel.history(until_attach: true) do |messages|
+              expect(messages.items.count).to eql(2)
+              stop_reactor
+            end
+          end
+
+          channel.attach
+        end
+      end
+
       context 'and two pages of messages' do
         it 'retrieves two pages of messages before channel was attached' do
           10.times { rest_channel.publish event, message_before_attach }

data/spec/acceptance/realtime/channel_spec.rb

@@ -83,6 +83,16 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
 
+        it 'sets attach_serial property after the attachment (#RTL15a)' do
+          expect(channel.properties.attach_serial).to be_nil
+
+          channel.attach
+          channel.on(:attached) do
+            expect(channel.properties.attach_serial).to_not be_nil
+            stop_reactor
+          end
+        end
+
         it 'sends an ATTACH and waits for an ATTACHED (#RTL4c)' do
           connection.once(:connected) do
             attach_count = 0
@@ -1393,6 +1403,20 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
       end
+
+      context 'message size exceeded (#TO3l8)' do
+        let(:message) { 'x' * 700000 }
+
+        let(:client) { auto_close Ably::Realtime::Client.new(client_options) }
+        let(:channel) { client.channels.get(channel_name) }
+
+        it 'should not allow to send a message' do
+          channel.publish('event', message).errback do |error|
+            expect(error).to be_instance_of(Ably::Exceptions::MaxMessageSizeExceeded)
+            stop_reactor
+          end
+        end
+      end
     end
 
     describe '#subscribe' do

data/spec/acceptance/realtime/client_spec.rb

@@ -87,22 +87,6 @@ describe Ably::Realtime::Client, :event_machine do
                 end
               end
             end
-
-            context 'with client_id' do
-              let(:client_options) do
-                default_options.merge(client_id: random_str)
-              end
-              it 'connects using token auth' do
-                run_reactor do
-                  connection.on(:connected) do
-                    expect(connection.state).to eq(:connected)
-                    expect(auth_params[:access_token]).to_not be_nil
-                    expect(auth_params[:key]).to be_nil
-                    stop_reactor
-                  end
-                end
-              end
-            end
           end
         end
 
@@ -249,6 +233,8 @@ describe Ably::Realtime::Client, :event_machine do
 
     context '#request (#RSC19*)' do
       let(:client_options) { default_options.merge(key: api_key) }
+      let(:device_id) { random_str }
+      let(:endpoint) { subject.rest_client.endpoint }
 
       context 'get' do
         it 'returns an HttpPaginatedResponse object' do
@@ -297,6 +283,76 @@ describe Ably::Realtime::Client, :event_machine do
           end
         end
       end
+
+
+      context 'post', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/deviceRegistrations/#{device_id}/resetUpdateToken").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports post' do
+          subject.request(:delete, "push/deviceRegistrations/#{device_id}/resetUpdateToken").callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'delete', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/channelSubscriptions?deviceId=#{device_id}").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports delete' do
+          subject.request(:delete, "/push/channelSubscriptions", { deviceId: device_id}).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'patch', :webmock do
+        let(:body_params) { { 'metadata' => { 'key' => 'value' } } }
+
+        before do
+          stub_request(:patch, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports patch' do
+          subject.request(:patch, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'put', :webmock do
+        let(:body_params) do
+          {
+            'id' => random_str,
+            'platform' => 'ios',
+            'formFactor' => 'phone',
+            'metadata' => { 'key' => 'value' }
+          }
+        end
+
+        before do
+          stub_request(:put, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports put' do
+          subject.request(:put, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
     end
 
     context '#publish (#TBC)' do

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -156,10 +156,20 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
               stub_request(:get, auth_url).
                 to_return do |request|
-                  sleep Ably::Rest::Client::HTTP_DEFAULTS.fetch(:request_timeout)
-                  { status: [500, "Internal Server Error"] }
-                end.then.
-                to_return(:status => 201, :body => token_response.to_json, :headers => { 'Content-Type' => 'application/json' })
+                sleep Ably::Rest::Client::HTTP_DEFAULTS.fetch(:request_timeout)
+                { status: [500, "Internal Server Error"] }
+              end.then.
+              to_return(:status => 201, :body => token_response.to_json, :headers => { 'Content-Type' => 'application/json' })
+
+              stub_request(:get, 'https://internet-up.ably-realtime.com/is-the-internet-up.txt')
+                .with(
+                  headers: {
+                    'Accept-Encoding' => 'gzip, compressed',
+                    'Connection' => 'close',
+                    'Host' => 'internet-up.ably-realtime.com',
+                    'User-Agent' => 'EventMachine HttpClient'
+                  }
+                ).to_return(status: 200, body: 'yes\n', headers: { 'Content-Type' => 'text/plain' })
             end
 
             specify 'the connection moves to the disconnected state and tries again, returning again to the disconnected state (#RSA4c, #RSA4c1, #RSA4c2)' do
@@ -1310,7 +1320,9 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             end)
           end
 
-          it 'triggers a re-authentication and then resumes the connection' do
+          xit 'triggers a re-authentication and then resumes the connection' do
+            # [PENDING] After sandbox env update connection isn't found and a new connection is created. Spec fails
+            #
             connection.once(:connected) do
               connection_id = connection.id
 
@@ -1423,14 +1435,19 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         let(:expected_host)  { "#{environment}-#{Ably::Realtime::Client::DOMAIN}" }
         let(:client_options) { timeout_options.merge(environment: environment) }
 
-        it 'does not use a fallback host by default' do
-          expect(connection).to receive(:create_transport).exactly(retry_count_for_all_states).times do |host|
-            expect(host).to eql(expected_host)
-            raise EventMachine::ConnectionError
-          end
+        context ':fallback_hosts_use_default is unset' do
+          let(:max_time_in_state_for_tests) { 8 }
+          let(:expected_hosts) { Ably::CUSTOM_ENVIRONMENT_FALLBACKS_SUFFIXES.map { |suffix| "#{environment}#{suffix}" } + [expected_host] }
+          let(:fallback_hosts_used) { Array.new }
+
+          it 'uses fallback hosts by default' do
+            allow(connection).to receive(:create_transport) do |host|
+              fallback_hosts_used << host
+              raise EventMachine::ConnectionError
+            end
 
-          connection.once(:suspended) do
             connection.once(:suspended) do
+              expect(fallback_hosts_used.uniq).to match_array(expected_hosts)
               stop_reactor
             end
           end
@@ -1508,7 +1525,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       end
 
       context 'with production environment' do
-        let(:custom_hosts)   { %w(A.ably-realtime.com B.ably-realtime.com) }
+        let(:custom_hosts)   { %w(a.ably-realtime.com b.ably-realtime.com) }
         before do
           stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
         end