ably-rest 1.0.6 → 1.1.4.rc

data/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/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
@@ -1338,5 +1339,42 @@ describe Ably::Auth do
         expect(response).to be_a(Ably::Models::TokenDetails)
       end
     end
+
+    # RSC1, RSC1a, RSA3c, RSA3d
+    context 'when using JWT' do
+      let(:auth_url) { 'https://echo.ably.io/createJWT' }
+      let(:token) { Faraday.get("#{auth_url}?keyName=#{key_name}&keySecret=#{key_secret}").body }
+      let(:client) { Ably::Rest::Client.new(token: token, environment: environment, protocol: protocol) }
+
+      it 'authenticates correctly using the JWT token generated by the echo server' do
+        expect(client.stats).to_not be_nil()
+      end
+
+      context 'when the JWT embeds an Ably token' do
+        let(:token) { Faraday.post(auth_url, { keyName: key_name, keySecret: key_secret, jwtType: :embedded }).body }
+
+        it 'authenticates correctly using the embedded token' do
+          expect(client.stats).to_not be_nil()
+        end
+
+        context 'and the requested token is encrypted' do
+          let(:token) { Faraday.post(auth_url, { keyName: key_name, keySecret: key_secret, jwtType: :embedded, encrypted: 1 }).body }
+
+          it 'authenticates correctly using the embedded token' do
+            expect(client.stats).to_not be_nil()
+          end
+        end
+      end
+
+      # RSA4f, RSA8c
+      context 'when the token requested is returned with application/jwt content type' do
+        let(:auth_rest_client) { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
+        let(:auth_params) { { keyName: key_name, keySecret: key_secret, returnType: 'jwt' } }
+        let(:token) { auth_rest_client.auth.request_token({ }, { auth_url: auth_url, auth_params: auth_params }).token }
+        it 'authenticates correctly and pulls stats' do
+          expect(client.stats).to_not be_nil()
+        end
+      end
+    end
   end
 end

data/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/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
@@ -275,6 +313,43 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'with a frozen message event name' do
+        let(:event_name) { random_str.freeze }
+
+        it 'succeeds and publishes with an implicit client_id' do
+          channel.publish([name: event_name])
+          channel.publish(event_name)
+
+          if !(RUBY_VERSION.match(/^1\./) || RUBY_VERSION.match(/^2\.[012]/))
+            channel.publish(+'foo-bar') # new style freeze, see https://github.com/ably/ably-ruby/issues/132
+          else
+            channel.publish('foo-bar'.freeze) # new + style not supported until Ruby 2.3
+          end
+
+          channel.history do |messages|
+            expect(messages.length).to eql(3)
+            expect(messages.first.name).to eql(event_name)
+            expect(messages[1].name).to eql(event_name)
+            expect(messages.last.name).to eql('foo-bar')
+          end
+        end
+      end
+
+      context 'with a frozen payload' do
+        let(:payload) { { foo: random_str.freeze }.freeze }
+
+        it 'succeeds and publishes with an implicit client_id' do
+          channel.publish([data: payload])
+          channel.publish(nil, payload)
+
+          channel.history do |messages|
+            expect(messages.length).to eql(2)
+            expect(messages.first.data).to eql(payload)
+            expect(messages.last.data).to eql(payload)
+          end
+        end
+      end
     end
 
     describe '#history' do

data/lib/submodules/ably-ruby/spec/acceptance/rest/channels_spec.rb

@@ -60,5 +60,11 @@ describe Ably::Rest::Channels do
       let(:channel_with_options) { client.channels[channel_name, options] }
       it_behaves_like 'a channel'
     end
+
+    describe 'using a frozen channel name' do
+      let(:channel) { client.channels[channel_name.freeze] }
+      let(:channel_with_options) { client.channels[channel_name.freeze, options] }
+      it_behaves_like 'a channel'
+    end
   end
 end

data/lib/submodules/ably-ruby/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