ably 1.0.7 → 1.1.0

data/spec/acceptance/realtime/push_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Realtime::Push, :event_machine do
+  vary_by_protocol do
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:client_options)  { default_options }
+    let(:client) do
+      Ably::Realtime::Client.new(client_options)
+    end
+    subject { client.push }
+
+    describe '#activate' do
+      it 'raises an unsupported exception' do
+        expect { subject.activate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+        stop_reactor
+      end
+    end
+
+    describe '#deactivate' do
+      it 'raises an unsupported exception' do
+        expect { subject.deactivate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+        stop_reactor
+      end
+    end
+  end
+end

data/spec/acceptance/rest/auth_spec.rb

@@ -758,9 +758,10 @@ describe Ably::Auth do
       end
 
       it 'updates the persisted auth options that are then used for subsequent authorize requests' do
-        expect(auth.options[:authUrl]).to be_nil
-        auth.authorize({}, authUrl: 'http://foo.com')
-        expect(auth.options[:authUrl]).to eql('http://foo.com')
+        auth_url = "https://echo.ably.io/?type=text&body=#{auth.request_token.token}"
+        expect(auth.options[:auth_url]).to be_nil
+        auth.authorize({}, auth_url: auth_url)
+        expect(auth.options[:auth_url]).to eql(auth_url)
       end
 
       context 'with a lambda for the :auth_callback option' do

data/spec/acceptance/rest/base_spec.rb

@@ -7,7 +7,7 @@ describe Ably::Rest do
 
     let(:client_options) { {} }
     let(:client) do
-      Ably::Rest::Client.new(client_options.merge(key: 'appid.keyuid:keysecret'))
+      Ably::Rest::Client.new(client_options.merge(key: 'appid.keyuid:keysecret', log_retries_as_info: true))
     end
 
     let(:now) { Time.now - 1000 }
@@ -67,7 +67,7 @@ describe Ably::Rest do
 
   vary_by_protocol do
     let(:client) do
-      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol)
+      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol, log_retries_as_info: true)
     end
 
     describe 'failed requests' do

data/spec/acceptance/rest/client_spec.rb

@@ -4,7 +4,7 @@ require 'webrick'
 
 describe Ably::Rest::Client do
   vary_by_protocol do
-    let(:default_options) { { environment: environment, protocol: protocol } }
+    let(:default_options) { { environment: environment, protocol: protocol, log_retries_as_info: true } }
     let(:client_options)  { default_options }
 
     let(:client) { Ably::Rest::Client.new(client_options) }
@@ -27,6 +27,19 @@ describe Ably::Rest::Client do
         end
       end
 
+      context 'with an invalid API key' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(key: 'app.key:secret', log_level: :fatal)) }
+
+        it 'logs an entry with a help href url matching the code #TI5' do
+          begin
+            client.channels.get('foo').publish('test')
+            raise 'Expected Ably::Exceptions::ResourceMissing'
+          rescue Ably::Exceptions::ResourceMissing => err
+            expect err.to_s.match(%r{https://help.ably.io/error/40400})
+          end
+        end
+      end
+
       context 'with an explicit string :token' do
         let(:client) { Ably::Rest::Client.new(client_options.merge(token: random_str)) }
 
@@ -710,6 +723,109 @@ describe Ably::Rest::Client do
               expect(@fallback_request_count).to eql(2)
             end
           end
+
+          context 'to fail the primary host, allow a fallback to succeed, then later trigger a fallback to the primary host (#RSC15f)' do
+            before do
+              @request_count = 0
+              @primary_host_request_count = 0
+              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false, :AccessLog => [], Logger: WEBrick::Log.new("/dev/null"))
+              @web_server.mount_proc "/channels/#{channel_name}/publish" do |req, res|
+                @request_count += 1
+                if req.header["host"].first.include?(primary_host)
+                  @primary_host_request_count += 1
+                  # Fail all requests to the primary host so that a fallback is used
+                  # Except request 6 which should suceed and clear the fallback host preference
+                  if @request_count == 6
+                    res.status = 200
+                    res['Content-Type'] = 'application/json'
+                    res.body = '{}'
+                  else
+                    res.status = 500
+                  end
+                else
+                  # Fail the second request (first failed fallback of first request)
+                  # Fail the third request on the previously succeeded fallback host to trigger an attempt on the primary host
+                  if [2, 5].include?(@request_count)
+                    res.status = 500
+                  else
+                    res.status = 200
+                    res['Content-Type'] = 'application/json'
+                    res.body = '{}'
+                  end
+                end
+              end
+
+              Thread.new do
+                @web_server.start
+              end
+            end
+
+            let(:client_options) do
+              default_options.merge(
+                rest_host: primary_host,
+                fallback_hosts: fallbacks,
+                token: 'fake.token',
+                port: port,
+                tls: false,
+                log_level: :error
+              ).merge(additional_client_options)
+            end
+
+            let (:additional_client_options) { {} }
+
+            it 'succeeds and remembers fallback host preferences across requests' do
+              # Send a request, expect primary endpoint to fail, one fallback to fail, second fallback to succeed
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(3)
+              expect(fallbacks).to include(client.using_preferred_fallback_host?)
+              successfull_fallback = client.using_preferred_fallback_host?
+              expect(@primary_host_request_count).to eql(1)
+
+              # Send another request, which should go straight to the fallback as it succeeded previously
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(4)
+              expect(successfull_fallback).to eql(client.using_preferred_fallback_host?)
+              expect(@primary_host_request_count).to eql(1)
+
+              # A subsequent request should fail to the fallback, go the primary host and succeed
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(6)
+              expect(client.using_preferred_fallback_host?).to be_falsey
+              expect(@primary_host_request_count).to eql(2)
+
+              # A subsequent request will fail on the primary endpoint, and we expect the fallback to be used again
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(8)
+              expect(fallbacks).to include(client.using_preferred_fallback_host?)
+              successfull_fallback = client.using_preferred_fallback_host?
+              expect(@primary_host_request_count).to eql(3)
+
+              # Send another request, which should go straight to the fallback as it succeeded previously
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(9)
+              expect(successfull_fallback).to eql(client.using_preferred_fallback_host?)
+              expect(@primary_host_request_count).to eql(3)
+            end
+
+            context 'with custom :fallback_retry_timeout' do
+              let (:additional_client_options) { { fallback_retry_timeout: 5 } }
+
+              it 'stops using the preferred fallback after this time' do
+                # Send a request, expect primary endpoint to fail, one fallback to fail, second fallback to succeed
+                client.channel(channel_name).publish('event', 'data')
+                expect(@request_count).to eql(3)
+                expect(fallbacks).to include(client.using_preferred_fallback_host?)
+                expect(@primary_host_request_count).to eql(1)
+
+                # Wait for the preferred fallback cache to expire
+                sleep 5
+
+                # Send another request, which should go straight to the primary host again as fallback host is expired
+                client.channel(channel_name).publish('event', 'data')
+                expect(@primary_host_request_count).to eql(2)
+              end
+            end
+          end
         end
       end
 
@@ -724,7 +840,8 @@ describe Ably::Rest::Client do
             environment: env,
             key: api_key,
             http_max_retry_duration: max_retry_duration,
-            http_max_retry_count: max_retry_count
+            http_max_retry_count: max_retry_count,
+            log_level: :fatal,
           )
         end
 
@@ -751,7 +868,7 @@ describe Ably::Rest::Client do
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :fatal)
           }
 
           it 'attempts the fallback hosts as this is not an authentication failure' do
@@ -764,7 +881,7 @@ describe Ably::Rest::Client do
 
         context 'with an empty array of fallback hosts provided (#RSC15b, #TO3k6)' do
           let(:client_options) {
-            production_options.merge(fallback_hosts: [])
+            production_options.merge(fallback_hosts: [], log_level: :fatal)
           }
 
           it 'does not attempt the fallback hosts as this is an authentication failure' do
@@ -789,7 +906,7 @@ describe Ably::Rest::Client do
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :fatal)
           }
 
           it 'attempts the default fallback hosts as this is an authentication failure' do
@@ -966,7 +1083,7 @@ describe Ably::Rest::Client do
           it 'sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)' do
             client.channels.get('foo').publish("event")
             expect(publish_message_stub).to have_been_requested
-            expect(Ably::PROTOCOL_VERSION).to eql('1.0')
+            expect(Ably::PROTOCOL_VERSION).to eql('1.1')
           end
         end
       end
@@ -1084,7 +1201,7 @@ describe Ably::Rest::Client do
         end
 
         context 'option add_request_ids: true and specified fallback hosts', :webmock do
-          let(:client_options) { { key: api_key, fallback_hosts_use_default: true, add_request_ids: true, log_level: :error } }
+          let(:client_options) { { key: api_key, fallback_hosts_use_default: true, add_request_ids: true, log_level: :error, log_retries_as_info: true } }
           let(:requests)       { [] }
 
           before do
@@ -1140,7 +1257,7 @@ describe Ably::Rest::Client do
 
     context 'failed request logging', :prevent_log_stubbing do
       let(:custom_logger) { TestLogger.new }
-      let(:client_options) { default_options.merge(key: api_key, logger: custom_logger) }
+      let(:client_options) { default_options.merge(key: api_key, logger: custom_logger, log_retries_as_info: false) }
 
       it 'is absent when requests do not fail' do
         client.time
@@ -1153,7 +1270,8 @@ describe Ably::Rest::Client do
             rest_host: 'non.existent.domain.local',
             fallback_hosts: [[environment, Ably::Rest::Client::DOMAIN].join('-')],
             key: api_key,
-            logger: custom_logger)
+            logger: custom_logger,
+            log_retries_as_info: false)
         end
 
         it 'is present with success message when requests do not actually fail' do
@@ -1169,7 +1287,8 @@ describe Ably::Rest::Client do
             rest_host: 'non.existent.domain.local',
             fallback_hosts: ['non2.existent.domain.local'],
             key: api_key,
-            logger: custom_logger)
+            logger: custom_logger,
+            log_retries_as_info: false)
         end
 
         it 'is present when all requests fail' do

data/spec/acceptance/rest/message_spec.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 require 'spec_helper'
+require 'base64'
 require 'securerandom'
 
 describe Ably::Rest::Channel, 'messages' do
@@ -91,11 +92,181 @@ describe Ably::Rest::Channel, 'messages' do
       end
     end
 
+    context 'idempotency (#RSL1k)' do
+      let(:id) { random_str }
+      let(:name) { 'event' }
+      let(:data) { random_str }
+
+      context 'when ID is not included (#RSL1k2)' do
+        context 'with Message object' do
+          let(:message) { Ably::Models::Message.new(data: data) }
+
+          it 'publishes the same message three times' do
+            3.times { channel.publish [message] }
+            expect(channel.history.items.length).to eql(3)
+          end
+        end
+
+        context 'with #publish arguments only' do
+          it 'publishes the same message three times' do
+            3.times { channel.publish 'event', data }
+            expect(channel.history.items.length).to eql(3)
+          end
+        end
+      end
+
+      context 'when ID is included (#RSL1k2, #RSL1k5)' do
+        context 'with Message object' do
+          let(:message) { Ably::Models::Message.new(id: id, data: data) }
+
+          specify 'three REST publishes result in only one message being published' do
+            pending 'idempotency rolled out to global cluster'
+
+            3.times { channel.publish [message] }
+            expect(channel.history.items.length).to eql(1)
+            expect(channel.history.items[0].id).to eql(id)
+          end
+        end
+
+        context 'with #publish arguments only' do
+          it 'three REST publishes result in only one message being published' do
+            pending 'idempotency rolled out to global cluster'
+
+            3.times { channel.publish 'event', data, id: id }
+            expect(channel.history.items.length).to eql(1)
+          end
+        end
+
+        specify 'the ID provided is used for the published messages' do
+          channel.publish 'event', data, id: id
+          expect(channel.history.items[0].id).to eql(id)
+        end
+
+        specify 'for multiple messages in one publish operation (#RSL1k3)' do
+          pending 'idempotency rolled out to global cluster'
+
+          message_arr = 3.times.map { Ably::Models::Message.new(id: id, data: data) }
+          expect { channel.publish message_arr }.to raise_error do |error|
+            expect(error.code).to eql(40031) # Invalid publish request (invalid client-specified id), see https://github.com/ably/ably-common/pull/30
+          end
+        end
+
+        specify 'for multiple messages in one publish operation with IDs following the required format described in RSL1k1 (#RSL1k3)' do
+          pending 'idempotency rolled out to global cluster'
+
+          message_arr = 3.times.map { |index| Ably::Models::Message.new(id: "#{id}:#{index}", data: data) }
+          channel.publish message_arr
+          expect(channel.history.items[0].id).to eql("{id}:0")
+          expect(channel.history.items[2].id).to eql("{id}:2")
+          expect(channel.history.items.length).to eql(3)
+        end
+      end
+
+      specify 'idempotent publishing is disabled by default with 1.1 (#TO3n)' do
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+        expect(client.idempotent_rest_publishing).to be_falsey
+      end
+
+      specify 'idempotent publishing is enabled by default with 1.2 (#TO3n)' do
+        stub_const 'Ably::VERSION', '1.2.0'
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+        expect(client.idempotent_rest_publishing).to be_truthy
+      end
+
+      context 'when idempotent publishing is enabled in the client library ClientOptions (#TO3n)' do
+        let(:client_options) { default_client_options.merge(idempotent_rest_publishing: true, log_level: :error) }
+
+        context 'when there is a network failure triggering an automatic retry (#RSL1k4)' do
+          def mock_for_two_publish_failures
+            @failed_http_posts = 0
+            allow(client).to receive(:can_fallback_to_alternate_ably_host?).and_return(true)
+            allow_any_instance_of(Faraday::Connection).to receive(:post) do |*args|
+              @failed_http_posts += 1
+              if @failed_http_posts == 2
+                # Ensure the 3rd requests operates as normal
+                allow_any_instance_of(Faraday::Connection).to receive(:post).and_call_original
+              end
+              raise Faraday::ClientError.new('Fake client error')
+            end
+          end
+
+          context 'with Message object' do
+            let(:message) { Ably::Models::Message.new(data: data) }
+            before { mock_for_two_publish_failures }
+
+            specify 'two REST publish retries result in only one message being published' do
+              pending 'idempotency rolled out to global cluster'
+
+              channel.publish [message]
+              expect(channel.history.items.length).to eql(1)
+              expect(@failed_http_posts).to eql(2)
+            end
+          end
+
+          context 'with #publish arguments only' do
+            before { mock_for_two_publish_failures }
+
+            specify 'two REST publish retries result in only one message being published' do
+              pending 'idempotency rolled out to global cluster'
+
+              channel.publish 'event', data
+              expect(channel.history.items.length).to eql(1)
+              expect(@failed_http_posts).to eql(2)
+            end
+          end
+
+          context 'with explicitly provided message ID' do
+            let(:id) { random_str }
+
+            before { mock_for_two_publish_failures }
+
+            specify 'two REST publish retries result in only one message being published' do
+              pending 'idempotency rolled out to global cluster'
+
+              channel.publish 'event', data, id: id
+              expect(channel.history.items.length).to eql(1)
+              expect(channel.history.items[0].id).to eql(id)
+              expect(@failed_http_posts).to eql(2)
+            end
+          end
+
+          specify 'for multiple messages in one publish operation' do
+            pending 'idempotency rolled out to global cluster'
+
+            message_arr = 3.times.map { Ably::Models::Message.new(data: data) }
+            3.times { channel.publish message_arr }
+            expect(channel.history.items.length).to eql(message_arr.length)
+          end
+        end
+
+        specify 'the ID is populated with a random ID and serial 0 from this lib (#RSL1k1)' do
+          channel.publish 'event'
+          expect(channel.history.items[0].id).to match(/^[A-Za-z0-9\+\/]+:0$/)
+          base_64_id = channel.history.items[0].id.split(':')[0]
+          expect(Base64.decode64(base_64_id).length).to eql(9)
+        end
+
+        context 'when publishing a batch of messages' do
+          specify 'the ID is populated with a single random ID and sequence of serials from this lib (#RSL1k1)' do
+            pending 'idempotency rolled out to global cluster'
+
+            message = { name: 'event' }
+            channel.publish [message, message, message]
+            expect(channel.history.items[0].length).to eql(3)
+            expect(channel.history.items[0].id).to match(/^[A-Za-z0-9\+\/]+:0$/)
+            expect(channel.history.items[2].id).to match(/^[A-Za-z0-9\+\/]+:2$/)
+            base_64_id = channel.history.items[0].id.split(':')[0]
+            expect(Base64.decode64(base_64_id).length).to eql(9)
+          end
+        end
+      end
+    end
+
     context 'with unsupported data payload content type' do
       context 'Integer' do
         let(:data) { 1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end
@@ -103,7 +274,7 @@ describe Ably::Rest::Channel, 'messages' do
       context 'Float' do
         let(:data) { 1.1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end
@@ -111,7 +282,7 @@ describe Ably::Rest::Channel, 'messages' do
       context 'Boolean' do
         let(:data) { true }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end
@@ -119,7 +290,7 @@ describe Ably::Rest::Channel, 'messages' do
       context 'False' do
         let(:data) { false }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end