ably 1.1.2 → 1.1.6

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -52,63 +52,5 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
       presence_client_one.enter(data)
     end
-
-    context 'with option until_attach: true' do
-      let(:event) { random_str }
-      let(:presence_data_before_attach) { random_str }
-      let(:presence_data_after_attach) { random_str }
-
-      it 'retrieves all presence messages before channel was attached' do
-        presence_client_two.enter(presence_data_before_attach) do
-          presence_client_one.enter(presence_data_after_attach) do
-            presence_client_one.history(until_attach: true) do |presence_page|
-              expect(presence_page.items.count).to eql(1)
-              expect(presence_page.items.first.data).to eql(presence_data_before_attach)
-              stop_reactor
-            end
-          end
-        end
-      end
-
-      context 'and two pages of messages' do
-        let(:wildcard_token) { lambda { |token_params| Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') } }
-        let(:client_one)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-        let(:client_two)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-
-        # TODO: Remove retry logic when presence history regression fixed
-        #       https://github.com/ably/realtime/issues/1707
-        #
-        it 'retrieves two pages of messages before channel was attached', retry: 10, :retry_wait => 5 do
-          when_all(*10.times.map { |i| presence_client_two.enter_client("client:#{i}", presence_data_before_attach) }) do
-            when_all(*10.times.map { |i| presence_client_one.enter_client("client:#{i}", presence_data_after_attach) }) do
-              presence_client_one.history(until_attach: true, limit: 5) do |presence_page|
-                expect(presence_page.items.count).to eql(5)
-                expect(presence_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-
-                presence_page.next do |presence_next_page|
-                  expect(presence_next_page.items.count).to eql(5)
-                  expect(presence_next_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-                  if presence_next_page.has_next?
-                    presence_next_page.next do |last|
-                      expect(last.items.count).to eql(0)
-                    end
-                  else
-                    expect(presence_next_page).to be_last
-                  end
-                  stop_reactor
-                end
-              end
-            end
-          end
-        end
-      end
-
-      it 'fails with an exception unless state is attached' do
-        presence_client_one.history(until_attach: true).errback do |error|
-          expect(error.message).to match(/not attached/)
-          stop_reactor
-        end
-      end
-    end
   end
 end

data/spec/acceptance/realtime/presence_spec.rb

@@ -2449,6 +2449,60 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      describe '#RTP17b' do
+        let(:leave_action) { Ably::Models::PresenceMessage::ACTION.Leave }
+
+        it 'updates presence members on leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to be_empty
+                  stop_reactor
+                end
+
+                leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => client_two.connection.id,
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        end
+
+        it 'does no update presence members on fabricated leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to_not be_empty
+                  stop_reactor
+                end
+
+                fabricated_leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => "fabricated:#{presence_client_two.client_id}:0",
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, fabricated_leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        end
+      end
+
       context 'when a channel becomes attached again' do
         let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached.to_i }
         let(:sync_action) { Ably::Models::ProtocolMessage::ACTION.Sync.to_i }

data/spec/acceptance/realtime/push_admin_spec.rb

@@ -101,31 +101,15 @@ describe Ably::Realtime::Push::Admin, :event_machine do
           end
         end
 
-        def request_body(request, protocol)
-          if protocol == :msgpack
-            MessagePack.unpack(request.body)
-          else
-            JSON.parse(request.body)
-          end
-        end
-
-        def serialize(object, protocol)
-          if protocol == :msgpack
-            MessagePack.pack(object)
-          else
-            JSON.dump(object)
-          end
-        end
-
         let!(:publish_stub) do
           stub_request(:post, "#{client.rest_client.endpoint}/push/publish").
             with do |request|
-              expect(request_body(request, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
-              expect(request_body(request, protocol)['recipient']).to_not have_key('camel_case')
+              expect(deserialize_body(request.body, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
+              expect(deserialize_body(request.body, protocol)['recipient']).to_not have_key('camel_case')
               true
             end.to_return(
               :status => 201,
-              :body => serialize({}, protocol),
+              :body => serialize_body({}, protocol),
               :headers => { 'Content-Type' => content_type }
             )
         end

data/spec/acceptance/rest/auth_spec.rb

@@ -41,22 +41,10 @@ describe Ably::Auth do
     end
 
     def request_body_includes(request, protocol, key, val)
-      body = if protocol == :msgpack
-        MessagePack.unpack(request.body)
-      else
-        JSON.parse(request.body)
-      end
+      body = deserialize_body(request.body, protocol)
       body[convert_to_mixed_case(key)].to_s == val.to_s
     end
 
-    def serialize(object, protocol)
-      if protocol == :msgpack
-        MessagePack.pack(object)
-      else
-        JSON.dump(object)
-      end
-    end
-
     it 'has immutable options' do
       expect { auth.options['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
     end
@@ -74,7 +62,7 @@ describe Ably::Auth do
 
       it 'creates a TokenRequest automatically and sends it to Ably to obtain a token', webmock: true do
         token_request_stub = stub_request(:post, "#{client.endpoint}/keys/#{key_name}/requestToken").
-          to_return(status: 201, body: serialize({}, protocol), headers: { 'Content-Type' => content_type })
+          to_return(status: 201, body: serialize_body({}, protocol), headers: { 'Content-Type' => content_type })
         expect(auth).to receive(:create_token_request).and_call_original
         auth.request_token
 
@@ -107,7 +95,7 @@ describe Ably::Auth do
                 request_body_includes(request, protocol, token_param, coerce_if_time_value(token_param, random, multiply: 1000))
               end.to_return(
                 :status => 201,
-                :body => serialize(token_response, protocol),
+                :body => serialize_body(token_response, protocol),
                 :headers => { 'Content-Type' => content_type }
               )
           end
@@ -138,7 +126,7 @@ describe Ably::Auth do
               request_body_includes(request, protocol, 'mac', mac)
             end.to_return(
               :status => 201,
-              :body => serialize(token_response, protocol),
+              :body => serialize_body(token_response, protocol),
               :headers => { 'Content-Type' => content_type })
         end
 
@@ -168,7 +156,7 @@ describe Ably::Auth do
               request_body_includes(request, protocol, 'mac', mac)
             end.to_return(
               :status => 201,
-              :body => serialize(token_response, protocol),
+              :body => serialize_body(token_response, protocol),
               :headers => { 'Content-Type' => content_type })
         end
 
@@ -310,7 +298,7 @@ describe Ably::Auth do
               request_body_includes(request, protocol, 'key_name', key_name)
             end.to_return(
               :status => 201,
-              :body => serialize(token_response, protocol),
+              :body => serialize_body(token_response, protocol),
               :headers => { 'Content-Type' => content_type }
             )
         end
@@ -1129,63 +1117,6 @@ describe Ably::Auth do
         end
       end
 
-      context 'when implicit as a result of using :client_id' do
-        let(:client_id) { '999' }
-        let(:client) do
-          Ably::Rest::Client.new(key: api_key, client_id: client_id, environment: environment, protocol: protocol)
-        end
-        let(:token) { 'unique-token' }
-        let(:token_response) do
-          {
-            token: token
-          }.to_json
-        end
-
-        context 'and requests to the Ably server are mocked', :webmock do
-          let!(:request_token_stub) do
-            stub_request(:post, "#{client.endpoint}/keys/#{key_name}/requestToken").
-              to_return(:status => 201, :body => token_response, :headers => { 'Content-Type' => 'application/json' })
-          end
-          let!(:publish_message_stub) do
-            stub_request(:post, "#{client.endpoint}/channels/foo/publish").
-              with(headers: { 'Authorization' => "Bearer #{encode64(token)}" }).
-              to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
-          end
-
-          it 'will send a token request to the server' do
-            client.channel('foo').publish('event', 'data')
-            expect(request_token_stub).to have_been_requested
-          end
-        end
-
-        describe 'a token is created' do
-          let(:token) { client.auth.current_token_details }
-
-          it 'before a request is made' do
-            expect(token).to be_nil
-          end
-
-          it 'when a message is published' do
-            expect(client.channel('foo').publish('event', 'data')).to be_truthy
-          end
-
-          it 'with capability and TTL defaults (#TK2a, #TK2b)' do
-            client.channel('foo').publish('event', 'data')
-
-            expect(token).to be_a(Ably::Models::TokenDetails)
-            capability_with_str_key = { "*" => ["*"] } # Ably default is all capabilities
-            capability = Hash[capability_with_str_key.keys.map(&:to_s).zip(capability_with_str_key.values)]
-            expect(token.capability).to eq(capability)
-            expect(token.expires.to_i).to be_within(2).of(Time.now.to_i + 60 * 60) # Ably default is 1hr
-            expect(token.client_id).to eq(client_id)
-          end
-
-          specify '#client_id contains the client_id' do
-            expect(client.auth.client_id).to eql(client_id)
-          end
-        end
-      end
-
       context 'when token expires' do
         before do
           stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0 # allow token to be used even if about to expire

data/spec/acceptance/rest/base_spec.rb

@@ -87,8 +87,10 @@ describe Ably::Rest do
         let(:error_response) { '{ "error": { "statusCode": 500, "code": 50000, "message": "Internal error" } }' }
 
         before do
-          stub_request(:get, "#{client.endpoint}/time").
-            to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
+          (client.fallback_hosts.map { |host| "https://#{host}" } + [client.endpoint]).each do |host|
+            stub_request(:get, "#{host}/time")
+              .to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
+          end
         end
 
         it 'should raise a ServerError exception' do
@@ -98,8 +100,10 @@ describe Ably::Rest do
 
       describe '500 server error without a valid JSON response body', :webmock do
         before do
-          stub_request(:get, "#{client.endpoint}/time").
-          to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
+          (client.fallback_hosts.map { |host| "https://#{host}" } + [client.endpoint]).each do |host|
+            stub_request(:get, "#{host}/time").
+            to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
+          end
         end
 
         it 'should raise a ServerError exception' do

data/spec/acceptance/rest/channel_spec.rb

@@ -40,7 +40,7 @@ describe Ably::Rest::Channel do
 
         it 'publishes the message without a client_id' do
           expect(client).to receive(:post).
-            with("/channels/#{channel_name}/publish", hash_excluding(client_id: client_id)).
+            with("/channels/#{channel_name}/publish", hash_excluding(client_id: client_id), {}).
             and_return(double('response', status: 201))
 
           expect(channel.publish(name, data)).to eql(true)
@@ -82,6 +82,44 @@ describe Ably::Rest::Channel do
         end
       end
 
+      context 'with a Message object' do
+        let(:name) { random_str }
+
+        let(:message) do
+          Ably::Models::Message(name: name, data: data)
+        end
+
+        it 'publishes the message' do
+          expect(client).to receive(:post).once.and_call_original
+          expect(channel.publish(message)).to eql(true)
+          expect(channel.history.items.first.name).to eql(name)
+        end
+      end
+
+      context 'with a Message object and query params' do
+        let(:message) do
+          Ably::Models::Message(name: name, data: data)
+        end
+
+        it 'should fail to publish the message (RSL1l1)' do
+          expect(client).to receive(:post).once.and_call_original
+          expect { channel.publish(message, { _forceNack: 'true' }) }.to raise_error(Ably::Exceptions::InvalidRequest, /40099/)
+        end
+      end
+
+      context 'with Messages and query params' do
+        let(:messages) do
+          10.times.map do |index|
+            { name: index.to_s, data: { "index" => index + 10 } }
+          end
+        end
+
+        it 'should fail to publish the message (RSL1l1)' do
+          expect(client).to receive(:post).once.and_call_original
+          expect { channel.publish(messages, { _forceNack: 'true' }) }.to raise_error(Ably::Exceptions::InvalidRequest, /40099/)
+        end
+      end
+
       context 'without adequate permissions on the channel' do
         let(:capability)     { { onlyChannel: ['subscribe'] } }
         let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { capability: capability }) }
@@ -96,7 +134,7 @@ describe Ably::Rest::Channel do
           let(:data) { random_str }
 
           it 'publishes the message without a name attribute in the payload' do
-            expect(client).to receive(:post).with(anything, { "data" => data }).once.and_call_original
+            expect(client).to receive(:post).with(anything, { "data" => data }, {}).once.and_call_original
             expect(channel.publish(nil, data)).to eql(true)
             expect(channel.history.items.first.name).to be_nil
             expect(channel.history.items.first.data).to eql(data)
@@ -107,7 +145,7 @@ describe Ably::Rest::Channel do
           let(:name) { random_str }
 
           it 'publishes the message without a data attribute in the payload' do
-            expect(client).to receive(:post).with(anything, { "name" => name }).once.and_call_original
+            expect(client).to receive(:post).with(anything, { "name" => name }, {}).once.and_call_original
             expect(channel.publish(name)).to eql(true)
             expect(channel.history.items.first.name).to eql(name)
             expect(channel.history.items.first.data).to be_nil
@@ -118,7 +156,7 @@ describe Ably::Rest::Channel do
           let(:name) { random_str }
 
           it 'publishes the message without any attributes in the payload' do
-            expect(client).to receive(:post).with(anything, {}).once.and_call_original
+            expect(client).to receive(:post).with(anything, {}, {}).once.and_call_original
             expect(channel.publish(nil)).to eql(true)
             expect(channel.history.items.first.name).to be_nil
             expect(channel.history.items.first.data).to be_nil

data/spec/acceptance/rest/client_spec.rb

@@ -12,7 +12,7 @@ describe Ably::Rest::Client do
     http_defaults = Ably::Rest::Client::HTTP_DEFAULTS
 
     def encode64(text)
-      Base64.encode64(text).gsub("\n", '')
+      Base64.urlsafe_encode64(text)
     end
 
     context '#initialize' do
@@ -56,14 +56,6 @@ describe Ably::Rest::Client do
         end
       end
 
-      context 'with a :client_id configured' do
-        let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: random_str)) }
-
-        it 'uses token authentication' do
-          expect(client.auth).to be_using_token_auth
-        end
-      end
-
       context 'with a non string :client_id' do
         let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: 1)) }
 
@@ -144,11 +136,12 @@ describe Ably::Rest::Client do
         let(:history_querystring) { history_params.map { |k, v| "#{k}=#{v}" }.join("&") }
 
         context 'with basic auth', webmock: true do
-          let(:client_options)      { default_options.merge(key: api_key) }
+          let(:client_options)      { default_options.merge(key: api_key, client_id: client_id) }
 
           let!(:get_message_history_stub) do
-            stub_request(:get, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}").
-              to_return(body: [], headers: { 'Content-Type' => 'application/json' })
+            stub_request(:get, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}")
+              .with(headers: { 'X-Ably-ClientId' => encode64(client_id) })
+              .to_return(body: [], headers: { 'Content-Type' => 'application/json' })
           end
 
           it 'sends the API key in authentication part of the secure URL (the Authorization: Basic header is not used with the Faraday HTTP library by default)' do
@@ -308,30 +301,44 @@ describe Ably::Rest::Client do
       context 'configured' do
         let(:client_options) { default_options.merge(key: api_key, environment: 'production') }
 
-        it 'should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com (#RSC15a)' do
+        it 'should make connection attempts to a.ably-realtime.com, b.ably-realtime.com, c.ably-realtime.com, d.ably-realtime.com, e.ably-realtime.com (#RSC15a)' do
           hosts = []
           5.times do
             hosts << client.fallback_connection.host
           end
-          expect(hosts).to match_array(%w(A.ably-realtime.com B.ably-realtime.com C.ably-realtime.com D.ably-realtime.com E.ably-realtime.com))
+          expect(hosts).to match_array(%w(a.ably-realtime.com b.ably-realtime.com c.ably-realtime.com d.ably-realtime.com e.ably-realtime.com))
         end
       end
 
       context 'when environment is NOT production (#RSC15b)' do
-        let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key) }
-        let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
-            raise Faraday::TimeoutError.new('timeout error message')
+        context 'and custom fallback hosts are empty' do
+          let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key, fallback_hosts: []) }
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+              raise Faraday::TimeoutError.new('timeout error message')
+            end
+          end
+
+          it 'does not retry failed requests with fallback hosts when there is a connection error' do
+            expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeout
           end
         end
 
-        it 'does not retry failed requests with fallback hosts when there is a connection error' do
-          expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeout
+        context 'and no custom fallback hosts are provided' do
+          let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key) }
+
+          it 'should make connection attempts to sandbox-a-fallback.ably-realtime.com, sandbox-b-fallback.ably-realtime.com, sandbox-c-fallback.ably-realtime.com, sandbox-d-fallback.ably-realtime.com, sandbox-e-fallback.ably-realtime.com (#RSC15a)' do
+            hosts = []
+            5.times do
+              hosts << client.fallback_connection.host
+            end
+            expect(hosts).to match_array(%w(a b c d e).map { |id| "sandbox-#{id}-fallback.ably-realtime.com" })
+          end
         end
       end
 
       context 'when environment is production' 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) }
         let(:max_retry_count)    { 2 }
         let(:max_retry_duration) { 0.5 }
         let(:fallback_block)     { proc { raise Faraday::SSLError.new('ssl error message') } }
@@ -830,11 +837,12 @@ describe Ably::Rest::Client do
       end
 
       context 'when environment is not production and server returns a 50x error' do
+        let(:env)                { 'custom-env' }
+        let(:default_fallbacks)  { %w(a b c d e).map { |id| "#{env}-#{id}-fallback.ably-realtime.com" } }
         let(:custom_hosts)       { %w(A.foo.com B.foo.com) }
         let(:max_retry_count)    { 2 }
         let(:max_retry_duration) { 0.5 }
         let(:fallback_block)     { proc { raise Faraday::SSLError.new('ssl error message') } }
-        let(:env)                { 'custom-env' }
         let(:production_options) do
           default_options.merge(
             environment: env,
@@ -858,6 +866,26 @@ describe Ably::Rest::Client do
           stub_request(:post, "https://#{env}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
         end
 
+        context 'with no fallback hosts provided (#TBC, see https://github.com/ably/wiki/issues/361)' do
+          let(:client_options) {
+            production_options.merge(log_level: :fatal)
+          }
+
+          it 'uses the default fallback hosts for that environment as this is not an authentication failure' do
+            fallbacks_called_count = 0
+            default_fallbacks.each do |host|
+              counting_fallback_proc = proc do
+                fallbacks_called_count += 1
+                fallback_block.call
+              end
+              stub_request(:post, "https://#{host}#{path}").to_return(&counting_fallback_proc)
+            end
+            expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
+            expect(default_host_request_stub).to have_been_requested
+            expect(fallbacks_called_count).to be >= 2
+          end
+        end
+
         context 'with custom fallback hosts provided (#RSC15b, #TO3k6)' do
           let!(:first_fallback_request_stub) do
             stub_request(:post, "https://#{custom_hosts[0]}#{path}").to_return(&fallback_block)
@@ -1091,6 +1119,8 @@ describe Ably::Rest::Client do
 
     context '#request (#RSC19*)' do
       let(:client_options) { default_options.merge(key: api_key) }
+      let(:device_id) { random_str }
+      let(:endpoint) { client.endpoint }
 
       context 'get' do
         it 'returns an HttpPaginatedResponse object' do
@@ -1130,13 +1160,78 @@ describe Ably::Rest::Client 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
+          response = client.request(:delete, "push/deviceRegistrations/#{device_id}/resetUpdateToken")
+
+          expect(response).to be_success
+        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
+          response = client.request(:delete, "/push/channelSubscriptions", { deviceId: device_id})
+
+          expect(response).to be_success
+        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
+          response = client.request(:patch, "/push/deviceRegistrations/#{device_id}", {}, body_params)
+
+          expect(response).to be_success
+        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
+          response = client.request(:put, "/push/deviceRegistrations/#{device_id}", {}, body_params)
+
+          expect(response).to be_success
+        end
+      end
     end
 
     context 'request_id generation' do
       context 'Timeout error' do
-        context 'with option add_request_ids: true', :webmock, :prevent_log_stubbing do
+        context 'with option add_request_ids: true and no fallback hosts', :webmock, :prevent_log_stubbing do
           let(:custom_logger_object) { TestLogger.new }
-          let(:client_options) { default_options.merge(key: api_key, logger: custom_logger_object, add_request_ids: true) }
+          let(:client_options) { default_options.merge(key: api_key, logger: custom_logger_object, add_request_ids: true, fallback_hosts: []) }
 
           before do
             @request_id = nil
@@ -1226,8 +1321,8 @@ describe Ably::Rest::Client do
           end
         end
 
-        context 'without request_id' do
-          let(:client_options) { default_options.merge(key: api_key, http_request_timeout: 0) }
+        context 'without request_id and no fallback hosts' do
+          let(:client_options) { default_options.merge(key: api_key, http_request_timeout: 0, fallback_hosts: []) }
 
           it 'does not include request_id in ConnectionTimeout error' do
             begin