ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,165 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest do
+  describe 'transport protocol' do
+    include Ably::Modules::Conversions
+
+    let(:client_options) { {} }
+    let(:client) do
+      Ably::Rest::Client.new(client_options.merge(api_key: 'appid.keyuid:keysecret'))
+    end
+
+    let(:now) { Time.now - 1000 }
+    let(:body_value) { [as_since_epoch(now)] }
+
+    before do
+      stub_request(:get, "#{client.endpoint}/time").
+        with(:headers => { 'Accept' => mime }).
+        to_return(:status => 200, :body => request_body, :headers => { 'Content-Type' => mime })
+    end
+
+    context 'when protocol is not defined it defaults to :msgpack' do
+      let(:client_options) { { } }
+      let(:mime) { 'application/x-msgpack' }
+      let(:request_body) { body_value.to_msgpack }
+
+      it 'uses MsgPack', :webmock do
+        expect(client.protocol).to eql(:msgpack)
+        expect(client.time).to be_within(1).of(now)
+      end
+    end
+
+    options = [
+        { protocol: :json },
+        { use_binary_protocol: false }
+      ].each do |client_option|
+
+      context "when option #{client_option} is used" do
+        let(:client_options) { client_option }
+        let(:mime) { 'application/json' }
+        let(:request_body) { body_value.to_json }
+
+        it 'uses JSON', :webmock do
+          expect(client.protocol).to eql(:json)
+          expect(client.time).to be_within(1).of(now)
+        end
+      end
+    end
+
+    options = [
+        { protocol: :msgpack },
+        { use_binary_protocol: true }
+      ].each do |client_option|
+
+      context "when option #{client_option} is used" do
+        let(:client_options) { client_option }
+        let(:mime) { 'application/x-msgpack' }
+        let(:request_body) { body_value.to_msgpack }
+
+        it 'uses MsgPack', :webmock do
+          expect(client.protocol).to eql(:msgpack)
+          expect(client.time).to be_within(1).of(now)
+        end
+      end
+    end
+  end
+
+  vary_by_protocol do
+    let(:client) do
+      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+    end
+
+    describe 'failed requests' do
+      context 'due to invalid Auth' do
+        it 'should raise an InvalidRequest exception with a valid error message and code' do
+          invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret', environment: environment)
+          expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
+            expect(error).to be_a(Ably::Exceptions::InvalidRequest)
+            expect(error.message).to match(/invalid credentials/)
+            expect(error.code).to eql(40100)
+            expect(error.status).to eql(401)
+          end
+        end
+      end
+
+      describe 'server error with JSON error response body', :webmock 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' })
+        end
+
+        it 'should raise a ServerError exception' do
+          expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Internal error/)
+        end
+      end
+
+      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' })
+        end
+
+        it 'should raise a ServerError exception' do
+          expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Unknown/)
+        end
+      end
+    end
+
+    describe 'token authentication failures', :webmock do
+      let(:token_1) { { id: random_str } }
+      let(:token_2) { { id: random_str } }
+      let(:channel) { 'channelname' }
+
+      before do
+        @token_requests = 0
+        @publish_attempts = 0
+
+        stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").to_return do
+          @token_requests += 1
+          {
+            :body => { access_token: send("token_#{@token_requests}").merge(expires: Time.now.to_i + 3600) }.to_json,
+            :headers => { 'Content-Type' => 'application/json' }
+          }
+        end
+
+        stub_request(:post, "#{client.endpoint}/channels/#{channel}/publish").to_return do
+          @publish_attempts += 1
+          if [1, 3].include?(@publish_attempts)
+            { status: 201, :body => '[]', :headers => { 'Content-Type' => 'application/json' } }
+          else
+            raise Ably::Exceptions::InvalidRequest.new('Authentication failure', 401, 40140)
+          end
+        end
+      end
+
+      context 'when auth#token_renewable?' do
+        before do
+          client.auth.authorise
+        end
+
+        it 'should automatically reissue a token' do
+          client.channel(channel).publish('evt', 'msg')
+          expect(@publish_attempts).to eql(1)
+
+          client.channel(channel).publish('evt', 'msg')
+          expect(@publish_attempts).to eql(3)
+          expect(@token_requests).to eql(2)
+        end
+      end
+
+      context 'when NOT auth#token_renewable?' do
+        let(:client) { Ably::Rest::Client.new(token_id: 'token ID cannot be used to create a new token', environment: environment, protocol: protocol) }
+
+        it 'should raise an InvalidToken exception' do
+          client.channel(channel).publish('evt', 'msg')
+          expect(@publish_attempts).to eql(1)
+          expect { client.channel(channel).publish('evt', 'msg') }.to raise_error Ably::Exceptions::InvalidToken
+          expect(@token_requests).to eql(0)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Channel do
+  include Ably::Modules::Conversions
+
+  vary_by_protocol do
+    let(:client) do
+      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+    end
+
+    describe '#publish' do
+      let(:channel) { client.channel('test') }
+      let(:event)   { 'foo' }
+      let(:message) { 'woop!' }
+
+      it 'should publish the message adn return true indicating success' do
+        expect(channel.publish(event, message)).to eql(true)
+      end
+    end
+
+    describe '#history' do
+      let(:channel) { client.channel("persisted:#{random_str(4)}") }
+      let(:expected_history) do
+        [
+          { :name => 'test1', :data => 'foo' },
+          { :name => 'test2', :data => 'bar' },
+          { :name => 'test3', :data => 'baz' }
+        ]
+      end
+      let!(:before_published) { client.time }
+
+      before(:each) do
+        expected_history.each do |message|
+          channel.publish(message[:name], message[:data]) || raise('Unable to publish message')
+        end
+      end
+
+      it 'should return the current message history for the channel' do
+        actual_history = channel.history
+
+        expect(actual_history.size).to eql(3)
+
+        expected_history.each do |message|
+          message_name, message_data = message[:name], message[:data]
+          matching_message = actual_history.find { |message| message.name == message_name && message.data == message_data }
+          expect(matching_message).to be_a(Ably::Models::Message)
+        end
+      end
+
+      context 'message timestamps' do
+        it 'should all be after the messages were published' do
+          channel.history.each do |message|
+            expect(before_published.to_f).to be < message.timestamp.to_f
+          end
+        end
+      end
+
+      context 'message IDs' do
+        it 'should be unique' do
+          message_ids = channel.history.map(&:id).compact
+          expect(message_ids.count).to eql(3)
+          expect(message_ids.uniq.count).to eql(3)
+        end
+      end
+
+      it 'should return paged history using the PaginatedResource model' do
+        page_1 = channel.history(limit: 1)
+        page_2 = page_1.next_page
+        page_3 = page_2.next_page
+
+        all_items = [page_1[0].id, page_2[0].id, page_3[0].id]
+        expect(all_items.uniq).to eql(all_items)
+
+        expect(page_1.size).to eql(1)
+        expect(page_1).to_not be_last_page
+        expect(page_1).to be_first_page
+
+        # Page 2
+        expect(page_2.size).to eql(1)
+        expect(page_2).to_not be_last_page
+        expect(page_2).to_not be_first_page
+
+        # Page 3
+        expect(page_3.size).to eql(1)
+        expect(page_3).to be_last_page
+        expect(page_3).to_not be_first_page
+      end
+    end
+
+    describe '#history option' do
+      let(:channel_name) { "persisted:#{random_str(4)}" }
+      let(:channel) { client.channel(channel_name) }
+      let(:endpoint) do
+        client.endpoint.tap do |client_end_point|
+          client_end_point.user = key_id
+          client_end_point.password = key_secret
+        end
+      end
+
+      [:start, :end].each do |option|
+        describe ":#{option}", :webmock do
+          let!(:history_stub) {
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?#{option}=#{milliseconds}").
+              to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+          }
+
+          before do
+            channel.history(options)
+          end
+
+          context 'with milliseconds since epoch value' do
+            let(:milliseconds) { as_since_epoch(Time.now) }
+            let(:options) { { option => milliseconds } }
+
+            it 'uses this value in the history request' do
+              expect(history_stub).to have_been_requested
+            end
+          end
+
+          context 'with a Time object value' do
+            let(:time) { Time.now }
+            let(:milliseconds) { as_since_epoch(time) }
+            let(:options) { { option => time } }
+
+            it 'converts the value to milliseconds since epoch in the hisotry request' do
+              expect(history_stub).to have_been_requested
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Channels do
+  shared_examples 'a channel' do
+    it 'returns a channel object' do
+      expect(channel).to be_a Ably::Rest::Channel
+      expect(channel.name).to eql(channel_name)
+    end
+
+    it 'returns channel object and passes the provided options' do
+      expect(channel_with_options.options).to eql(options)
+    end
+  end
+
+  vary_by_protocol do
+    let(:client) do
+      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+    end
+    let(:channel_name) { random_str }
+    let(:options)      { { key: 'value' } }
+
+    describe 'using shortcut method #channel on the client object' do
+      let(:channel) { client.channel(channel_name) }
+      let(:channel_with_options) { client.channel(channel_name, options) }
+      it_behaves_like 'a channel'
+    end
+
+    describe 'using #get method on client#channels' do
+      let(:channel) { client.channels.get(channel_name) }
+      let(:channel_with_options) { client.channels.get(channel_name, options) }
+      it_behaves_like 'a channel'
+    end
+
+    describe 'using undocumented array accessor [] method on client#channels' do
+      let(:channel) { client.channels[channel_name] }
+      let(:channel_with_options) { client.channels[channel_name, options] }
+      it_behaves_like 'a channel'
+    end
+  end
+end

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

@@ -0,0 +1,273 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Client do
+  vary_by_protocol do
+    let(:default_options) { { environment: environment, protocol: protocol } }
+    let(:client_options)  { default_options }
+
+    let(:client) { Ably::Rest::Client.new(client_options) }
+
+    connection_retry = Ably::Rest::Client::CONNECTION_RETRY
+
+    context '#initialize' do
+      let(:client_id)     { random_str }
+      let(:token_request) { client.auth.create_token_request(key_id: key_id, key_secret: key_secret, client_id: client_id) }
+
+      context 'with an auth block' do
+        let(:client) { Ably::Rest::Client.new(client_options) { token_request } }
+
+        it 'calls the block to get a new token' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(client_id)
+        end
+      end
+
+      context 'with an auth URL' do
+        let(:client_options) { default_options.merge(auth_url: token_request_url, auth_method: :get) }
+        let(:token_request_url) { 'http://get.token.request.com/' }
+
+        before do
+          allow(client.auth).to receive(:token_request_from_auth_url).with(token_request_url, :auth_method => :get).and_return(token_request)
+        end
+
+        it 'sends an HTTP request to the provided URL to get a new token' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(client_id)
+        end
+      end
+    end
+
+    context 'using tokens' do
+      let(:client) do
+        Ably::Rest::Client.new(client_options) do
+          @request_index ||= 0
+          @request_index += 1
+          send("token_request_#{@request_index}")
+        end
+      end
+      let(:token_request_1) { client.auth.create_token_request(token_request_options.merge(client_id: random_str)) }
+      let(:token_request_2) { client.auth.create_token_request(token_request_options.merge(client_id: random_str)) }
+
+      context 'when expired' do
+        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: Ably::Models::Token::TOKEN_EXPIRY_BUFFER } }
+
+        it 'creates a new token automatically when the old token expires' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
+
+          sleep 1
+
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_2['clientId'])
+        end
+      end
+
+      context 'when token has not expired' do
+        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: 3600 } }
+
+        it 'reuses the existing token for every request' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
+
+          sleep 1
+
+          expect { client.channel('channel_name').publish('event', 'message') }.to_not change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
+        end
+      end
+    end
+
+    context 'connection transport' do
+      let(:client_options) { default_options.merge(api_key: api_key) }
+
+      context 'for default host' do
+        it "is configured to timeout connection opening in #{connection_retry.fetch(:single_request_open_timeout)} seconds" do
+          expect(client.connection.options.open_timeout).to eql(connection_retry.fetch(:single_request_open_timeout))
+        end
+
+        it "is configured to timeout connection requests in #{connection_retry.fetch(:single_request_timeout)} seconds" do
+          expect(client.connection.options.timeout).to eql(connection_retry.fetch(:single_request_timeout))
+        end
+      end
+
+      context 'for the fallback hosts' do
+        it "is configured to timeout connection opening in #{connection_retry.fetch(:single_request_open_timeout)} seconds" do
+          expect(client.fallback_connection.options.open_timeout).to eql(connection_retry.fetch(:single_request_open_timeout))
+        end
+
+        it "is configured to timeout connection requests in #{connection_retry.fetch(:single_request_timeout)} seconds" do
+          expect(client.fallback_connection.options.timeout).to eql(connection_retry.fetch(:single_request_timeout))
+        end
+      end
+    end
+
+    context 'fallback hosts', :webmock do
+      let(:path)           { '/channels/test/publish' }
+      let(:publish_block)  { proc { client.channel('test').publish('event', 'data') } }
+
+      context 'configured' do
+        let(:client_options) { default_options.merge(api_key: api_key) }
+
+        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' 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))
+        end
+      end
+
+      context 'when environment is NOT production' do
+        let(:client_options) { default_options.merge(environment: 'sandbox', api_key: api_key) }
+        let!(:default_host_request_stub) do
+          stub_request(:post, "https://#{api_key}@#{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::ConnectionTimeoutError
+        end
+      end
+
+      context 'when environment is production' do
+        let(:custom_hosts)       { %w(A.ably-realtime.com B.ably-realtime.com) }
+        let(:max_attempts)       { 2 }
+        let(:cumulative_timeout) { 0.5 }
+        let(:client_options)     { default_options.merge(environment: nil, api_key: api_key) }
+
+        before do
+          stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
+          stub_const 'Ably::Rest::Client::CONNECTION_RETRY', {
+            single_request_open_timeout: 4,
+            single_request_timeout: 15,
+            cumulative_request_open_timeout: cumulative_timeout,
+            max_retry_attempts: max_attempts
+          }
+        end
+
+        let!(:first_fallback_request_stub) do
+          stub_request(:post, "https://#{api_key}@#{custom_hosts[0]}#{path}").to_return do
+            raise Faraday::SSLError.new('ssl error message')
+          end
+        end
+
+        let!(:second_fallback_request_stub) do
+          stub_request(:post, "https://#{api_key}@#{custom_hosts[1]}#{path}").to_return do
+            raise Faraday::SSLError.new('ssl error message')
+          end
+        end
+
+        context 'and connection times out' do
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+              raise Faraday::TimeoutError.new('timeout error message')
+            end
+          end
+
+          it "tries fallback hosts #{connection_retry[:max_retry_attempts]} times" do
+            expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
+            expect(default_host_request_stub).to have_been_requested
+            expect(first_fallback_request_stub).to have_been_requested
+            expect(second_fallback_request_stub).to have_been_requested
+          end
+
+          context "and the total request time exeeds #{connection_retry[:cumulative_request_open_timeout]} seconds" do
+            let!(:default_host_request_stub) do
+              stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+                sleep cumulative_timeout * 1.5
+                raise Faraday::TimeoutError.new('timeout error message')
+              end
+            end
+
+            it 'makes no further attempts to any fallback hosts' do
+              expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeoutError
+              expect(default_host_request_stub).to have_been_requested
+              expect(first_fallback_request_stub).to_not have_been_requested
+              expect(second_fallback_request_stub).to_not have_been_requested
+            end
+          end
+        end
+
+        context 'and connection fails' do
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+              raise Faraday::ConnectionFailed.new('connection failure error message')
+            end
+          end
+
+          it "tries fallback hosts #{connection_retry[:max_retry_attempts]} times" do
+            expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
+            expect(default_host_request_stub).to have_been_requested
+            expect(first_fallback_request_stub).to have_been_requested
+            expect(second_fallback_request_stub).to have_been_requested
+          end
+        end
+      end
+    end
+
+    context 'with a custom host' do
+      let(:custom_host)   { 'host.does.not.exist' }
+      let(:client_options) { default_options.merge(api_key: api_key, rest_host: custom_host) }
+      let(:capability)     { { :foo => ["publish"] } }
+
+      context 'that does not exist' do
+        it 'fails immediately and raises a Faraday Error' do
+          expect { client.channel('test').publish('event', 'data') }.to raise_error Ably::Exceptions::ConnectionError
+        end
+
+        context 'fallback hosts', :webmock do
+          let(:path) { '/channels/test/publish' }
+
+          let!(:custom_host_request_stub) do
+            stub_request(:post, "https://#{api_key}@#{custom_host}#{path}").to_return do
+              raise Faraday::ConnectionFailed.new('connection failure error message')
+            end
+          end
+
+          before do
+            Ably::FALLBACK_HOSTS.each do |host|
+              stub_request(:post, "https://#{host}#{path}").to_return do
+                raise 'Fallbacks should not be used with custom hosts'
+              end
+            end
+          end
+
+          specify 'are never used' do
+            expect { client.channel('test').publish('event', 'data') }.to raise_error Ably::Exceptions::ConnectionError
+            expect(custom_host_request_stub).to have_been_requested
+          end
+        end
+      end
+
+      context 'that times out', :webmock do
+        let(:path) { '/keys/app_id.key_id/requestToken' }
+        let!(:custom_host_request_stub) do
+          stub_request(:post, "https://#{custom_host}#{path}").to_return do
+            raise Faraday::TimeoutError.new('timeout error message')
+          end
+        end
+
+        it 'fails immediately and raises a Faraday Error' do
+          expect { client.auth.request_token }.to raise_error Ably::Exceptions::ConnectionTimeoutError
+        end
+
+        context 'fallback hosts' do
+          before do
+            Ably::FALLBACK_HOSTS.each do |host|
+              stub_request(:post, "https://#{host}#{path}").to_return do
+                raise 'Fallbacks should not be used with custom hosts'
+              end
+            end
+          end
+
+          specify 'are never used' do
+            expect { client.auth.request_token }.to raise_error Ably::Exceptions::ConnectionTimeoutError
+            expect(custom_host_request_stub).to have_been_requested
+          end
+        end
+      end
+    end
+  end
+end