ably 1.1.4.rc → 1.1.7

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

@@ -60,6 +60,8 @@ describe Ably::Rest::Channel do
         end
 
         it 'publishes an array of messages in one HTTP request' do
+          expect(messages.sum(&:size) < Ably::Rest::Channel::MAX_MESSAGE_SIZE).to eq(true)
+
           expect(client).to receive(:post).once.and_call_original
           expect(channel.publish(messages)).to eql(true)
           expect(channel.history.items.map(&:name)).to match_array(messages.map { |message| message[:name] })
@@ -75,6 +77,8 @@ describe Ably::Rest::Channel do
         end
 
         it 'publishes an array of messages in one HTTP request' do
+          expect(messages.sum(&:size) < Ably::Rest::Channel::MAX_MESSAGE_SIZE).to eq(true)
+
           expect(client).to receive(:post).once.and_call_original
           expect(channel.publish(messages)).to eql(true)
           expect(channel.history.items.map(&:name)).to match_array(messages.map(&:name))
@@ -350,6 +354,15 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'message size is exceeded (#TO3l8)' do
+        let(:data) { 101.times.map { { data: 'x' * 655 } } }
+
+        it 'should raise Ably::Exceptions::MaxMessageSizeExceeded exception' do
+          expect { channel.publish([ data: data ]) }.to \
+            raise_error(Ably::Exceptions::MaxMessageSizeExceeded)
+        end
+      end
     end
 
     describe '#history' do

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)
@@ -1053,29 +1081,15 @@ describe Ably::Rest::Client do
     end
 
     context 'version headers', :webmock do
-      [nil, 'foo'].each do |variant|
-        context "with variant #{variant ? variant : 'none'}" do
-          if variant
-            before do
-              Ably.lib_variant = variant
-            end
+      [nil, 'ably-ruby/1.1.1 ruby/1.9.3'].each do |agent|
+        context "with #{agent ? "custom #{agent}" : 'default'} agent" do
+          let(:client_options) { default_options.merge(key: api_key, agent: agent) }
 
-            after do
-              Ably.lib_variant = nil
-            end
-          end
-
-          let(:client_options) { default_options.merge(key: api_key) }
           let!(:publish_message_stub) do
-            lib = ['ruby']
-            lib << variant if variant
-            lib << Ably::VERSION
-
-
             stub_request(:post, "#{client.endpoint}/channels/foo/publish").
               with(headers: {
                 'X-Ably-Version' => Ably::PROTOCOL_VERSION,
-                'X-Ably-Lib' => lib.join('-')
+                'Ably-Agent' => agent || Ably::AGENT
               }).
               to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
           end
@@ -1089,8 +1103,10 @@ describe Ably::Rest::Client do
       end
     end
 
-    context '#request (#RSC19*)' do
+    context '#request (#RSC19*, #TO3l9)' 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 +1146,96 @@ 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
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:post, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        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
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:patch, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        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
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:put, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        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 +1325,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