ably 0.8.2 → 0.8.3

data/spec/acceptance/rest/base_spec.rb

@@ -130,7 +130,7 @@ describe Ably::Rest do
           if [1, 3].include?(@publish_attempts)
             { status: 201, :body => '[]', :headers => { 'Content-Type' => 'application/json' } }
           else
-            raise Ably::Exceptions::InvalidRequest.new('Authentication failure', 401, 40140)
+            raise Ably::Exceptions::TokenExpired.new('Authentication failure', 401, 40140)
           end
         end
       end
@@ -155,10 +155,10 @@ describe Ably::Rest do
       context 'when NOT auth#token_renewable?' do
         let(:client) { Ably::Rest::Client.new(token: 'token ID cannot be used to create a new token', environment: environment, protocol: protocol) }
 
-        it 'should raise an InvalidToken exception' do
+        it 'should raise an TokenExpired 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 { client.channel(channel).publish('evt', 'msg') }.to raise_error Ably::Exceptions::TokenExpired
           expect(@token_requests).to eql(0)
         end
       end

data/spec/acceptance/rest/channel_spec.rb

@@ -5,17 +5,97 @@ describe Ably::Rest::Channel do
   include Ably::Modules::Conversions
 
   vary_by_protocol do
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:client_options)  { default_options }
     let(:client) do
-      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol)
+      Ably::Rest::Client.new(client_options)
     end
 
     describe '#publish' do
-      let(:channel) { client.channel('test') }
-      let(:event)   { 'foo' }
-      let(:message) { 'woop!' }
+      let(:channel) { client.channel(random_str) }
+      let(:name)   { 'foo' }
+      let(:data)    { 'woop!' }
 
-      it 'should publish the message and return true indicating success' do
-        expect(channel.publish(event, message)).to eql(true)
+      context 'with name and data arguments' do
+        it 'publishes the message and return true indicating success' do
+          expect(channel.publish(name, data)).to eql(true)
+          expect(channel.history.items.first.name).to eql(name)
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+
+      context 'with an array of Hash objects with :name and :data attributes' do
+        let(:messages) do
+          10.times.map do |index|
+            { name: index.to_s, data: { "index" => index + 10 } }
+          end
+        end
+
+        it 'publishes an array of messages in one HTTP request' do
+          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] })
+          expect(channel.history.items.map(&:data)).to match_array(messages.map { |message| message[:data] })
+        end
+      end
+
+      context 'with an array of Message objects' do
+        let(:messages) do
+          10.times.map do |index|
+            Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+          end
+        end
+
+        it 'publishes an array of messages in one HTTP request' do
+          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))
+          expect(channel.history.items.map(&:data)).to match_array(messages.map(&:data))
+        end
+      end
+
+      context 'without adequate permissions on the channel' do
+        let(:capability)     { { onlyChannel: ['subscribe'] } }
+        let(:client_options) { default_options.merge(use_token_auth: true, token_params: { capability: capability }) }
+
+        it 'raises a permission error when publishing' do
+          expect { channel.publish(name, data) }.to raise_error(Ably::Exceptions::InvalidRequest, /not permitted/)
+        end
+      end
+
+      context 'null attributes' do
+        context 'when name is null' 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(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)
+          end
+        end
+
+        context 'when data is null' 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(channel.publish(name)).to eql(true)
+            expect(channel.history.items.first.name).to eql(name)
+            expect(channel.history.items.first.data).to be_nil
+          end
+        end
+
+        context 'with neither name or data attributes' 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(channel.publish(nil)).to eql(true)
+            expect(channel.history.items.first.name).to be_nil
+            expect(channel.history.items.first.data).to be_nil
+          end
+        end
       end
     end
 
@@ -36,7 +116,11 @@ describe Ably::Rest::Channel do
         end
       end
 
-      it 'should return the current message history for the channel' do
+      it 'returns a PaginatedResult model' do
+        expect(channel.history).to be_a(Ably::Models::PaginatedResult)
+      end
+
+      it 'returns the current message history for the channel' do
         actual_history_items = channel.history.items
 
         expect(actual_history_items.size).to eql(3)
@@ -49,7 +133,7 @@ describe Ably::Rest::Channel do
       end
 
       context 'message timestamps' do
-        it 'should all be after the messages were published' do
+        specify 'are after the messages were published' do
           channel.history.items.each do |message|
             expect(before_published.to_f).to be < message.timestamp.to_f
           end
@@ -57,14 +141,14 @@ describe Ably::Rest::Channel do
       end
 
       context 'message IDs' do
-        it 'should be unique' do
+        it 'is unique' do
           message_ids = channel.history.items.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 PaginatedResult model' do
+      it 'returns paged history using the PaginatedResult model' do
         page_1 = channel.history(limit: 1)
         page_2 = page_1.next
         page_3 = page_2.next
@@ -74,17 +158,42 @@ describe Ably::Rest::Channel do
 
         expect(page_1.items.size).to eql(1)
         expect(page_1).to_not be_last
-        expect(page_1).to be_first
 
         # Page 2
         expect(page_2.items.size).to eql(1)
         expect(page_2).to_not be_last
-        expect(page_2).to_not be_first
 
         # Page 3
         expect(page_3.items.size).to eql(1)
         expect(page_3).to be_last
-        expect(page_3).to_not be_first
+      end
+
+      context 'direction' do
+        it 'returns paged history backwards by default' do
+          items = channel.history.items
+          expect(items.first.name).to eql(expected_history.last.fetch(:name))
+          expect(items.last.name).to eql(expected_history.first.fetch(:name))
+        end
+
+        it 'returns history forward if specified in the options' do
+          items = channel.history(direction: :forwards).items
+          expect(items.first.name).to eql(expected_history.first.fetch(:name))
+          expect(items.last.name).to eql(expected_history.last.fetch(:name))
+        end
+      end
+
+      context 'limit' do
+        before do
+          channel.publish 120.times.to_a.map { |i| { name: 'event' } }
+        end
+
+        it 'defaults to 100' do
+          page = channel.history
+          expect(page.items.count).to eql(100)
+          next_page = page.next
+          expect(next_page.items.count).to be >= 20
+          expect(next_page.items.count).to be < 100
+        end
       end
     end
 
@@ -97,7 +206,7 @@ describe Ably::Rest::Channel do
           client_end_point.password = key_secret
         end
       end
-      let(:default_options) do
+      let(:default_history_options) do
           {
             direction: :backwards,
             limit: 100
@@ -107,7 +216,8 @@ describe Ably::Rest::Channel do
       [:start, :end].each do |option|
         describe ":#{option}", :webmock do
           let!(:history_stub) {
-            query_params = default_options.merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
+            query_params = default_history_options
+            .merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
             stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?#{query_params}").
               to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
           }
@@ -136,6 +246,23 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'when argument start is after end' do
+        let(:subject) { channel.history(start: as_since_epoch(Time.now), end: Time.now - 120) }
+
+        it 'should raise an exception' do
+          expect { subject.items }.to raise_error ArgumentError
+        end
+      end
+    end
+
+    context '#presence' do
+      let(:channel_name) { "persisted:#{random_str(4)}" }
+      let(:channel) { client.channel(channel_name) }
+
+      it 'returns a REST Presence object' do
+        expect(channel.presence).to be_a(Ably::Rest::Presence)
+      end
     end
   end
 end

data/spec/acceptance/rest/channels_spec.rb

@@ -32,6 +32,29 @@ describe Ably::Rest::Channels do
       it_behaves_like 'a channel'
     end
 
+    describe 'accessing an existing channel object with different options' do
+      let(:new_channel_options) { { encrypted: true } }
+      let(:original_channel)    { client.channels.get(channel_name, options) }
+
+      it 'overrides the existing channel options and returns the channel object' do
+        expect(original_channel.options).to_not include(:encrypted)
+        new_channel = client.channels.get(channel_name, new_channel_options)
+        expect(new_channel).to be_a(Ably::Rest::Channel)
+        expect(new_channel.options[:encrypted]).to eql(true)
+      end
+    end
+
+    describe 'accessing an existing channel object without specifying any channel options' do
+      let(:original_channel) { client.channels.get(channel_name, options) }
+
+      it 'returns the existing channel without modifying the channel options' do
+        expect(original_channel.options).to eql(options)
+        new_channel = client.channels.get(channel_name)
+        expect(new_channel).to be_a(Ably::Rest::Channel)
+        expect(original_channel.options).to eql(options)
+      end
+    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] }

data/spec/acceptance/rest/client_spec.rb

@@ -10,30 +10,128 @@ describe Ably::Rest::Client do
 
     connection_retry = Ably::Rest::Client::CONNECTION_RETRY
 
+    def encode64(text)
+      Base64.encode64(text).gsub("\n", '')
+    end
+
     context '#initialize' do
       let(:client_id)     { random_str }
       let(:token_request) { client.auth.create_token_request(key_name: key_name, key_secret: key_secret, client_id: client_id) }
 
-      context 'with a :auth_callback Proc' do
+      context 'with only an API key' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key)) }
+
+        it 'uses basic authentication' do
+          expect(client.auth).to be_using_basic_auth
+        end
+      end
+
+      context 'with an explicit string :token' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(token: random_str)) }
+
+        it 'uses token authentication' do
+          expect(client.auth).to be_using_token_auth
+        end
+      end
+
+      context 'with :use_token_auth set to true' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key, use_token_auth: true)) }
+
+        it 'uses token authentication' do
+          expect(client.auth).to be_using_token_auth
+        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 an :auth_callback Proc' do
         let(:client) { Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new { token_request })) }
 
         it 'calls the auth Proc to get a new token' do
           expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
           expect(client.auth.current_token_details.client_id).to eql(client_id)
         end
+
+        it 'uses token authentication' do
+          expect(client.auth).to be_using_token_auth
+        end
       end
 
       context 'with an auth URL' do
-        let(:client_options) { default_options.merge(auth_url: token_request_url, auth_method: :get) }
+        let(:client_options)    { default_options.merge(key: api_key, 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)
+        it 'uses token authentication' do
+          expect(client.auth).to be_using_token_auth
         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_details }
-          expect(client.auth.current_token_details.client_id).to eql(client_id)
+        context 'before any REST request' do
+          before do
+            expect(client.auth).to receive(:token_request_from_auth_url).with(token_request_url, hash_including(:auth_method => :get)).once do
+              client.auth.create_token_request(token_params: { client_id: client_id })
+            end
+          end
+
+          it 'sends an HTTP request to the provided auth URL to get a new token' do
+            expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
+            expect(client.auth.current_token_details.client_id).to eql(client_id)
+          end
+        end
+      end
+
+      context 'auth headers', webmock: true do
+        let(:channel_name)        { random_str }
+        let(:history_params)      { { 'direction' => 'backwards', 'limit' => 100 } }
+        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!(:get_message_history_stub) do
+            stub_request(:get, "https://#{api_key}@#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}").
+              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
+            client.channel(channel_name).history history_params
+            expect(get_message_history_stub).to have_been_requested
+          end
+        end
+
+        context 'with token auth', webmock: true do
+          let(:token_string)   { random_str }
+          let(:client_options) { default_options.merge(token: token_string) }
+
+          let!(:get_message_history_stub) do
+            stub_request(:get, "#{http_protocol}://#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}").
+              with(headers: { 'Authorization' => "Bearer #{encode64(token_string)}" }).
+              to_return(body: [], headers: { 'Content-Type' => 'application/json' })
+          end
+
+          context 'without specifying protocol' do
+            let(:http_protocol) { 'https' }
+
+            it 'sends the token string over HTTPS in the Authorization Bearer header with Base64 encoding' do
+              client.channel(channel_name).history history_params
+              expect(get_message_history_stub).to have_been_requested
+            end
+          end
+
+          context 'when setting constructor ClientOption :tls to false' do
+            let(:client_options) { default_options.merge(token: token_string, tls: false) }
+            let(:http_protocol)  { 'http' }
+
+            it 'sends the token string over HTTP in the Authorization Bearer header with Base64 encoding' do
+              client.channel(channel_name).history history_params
+              expect(get_message_history_stub).to have_been_requested
+            end
+          end
         end
       end
     end
@@ -53,7 +151,12 @@ describe Ably::Rest::Client do
       let(:token_request_next) { client.auth.create_token_request(token_request_options.merge(client_id: random_str)) }
 
       context 'when expired' do
-        let(:token_request_options) { { key_name: key_name, key_secret: key_secret, ttl: Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER } }
+        before do
+          # Ensure tokens issued expire immediately after issue
+          stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0)
+        end
+
+        let(:token_request_options) { { key_name: key_name, key_secret: key_secret, token_params: { ttl: Ably::Models::TokenDetails::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_details }
@@ -130,7 +233,7 @@ describe Ably::Rest::Client do
         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
+          expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeout
         end
       end
 
@@ -139,6 +242,7 @@ describe Ably::Rest::Client do
         let(:max_attempts)       { 2 }
         let(:cumulative_timeout) { 0.5 }
         let(:client_options)     { default_options.merge(environment: nil, key: api_key) }
+        let(:fallback_block)     { Proc.new { raise Faraday::SSLError.new('ssl error message') } }
 
         before do
           stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
@@ -151,15 +255,11 @@ describe Ably::Rest::Client do
         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
+          stub_request(:post, "https://#{api_key}@#{custom_hosts[0]}#{path}").to_return(&fallback_block)
         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
+          stub_request(:post, "https://#{api_key}@#{custom_hosts[1]}#{path}").to_return(&fallback_block)
         end
 
         context 'and connection times out' do
@@ -185,7 +285,7 @@ describe Ably::Rest::Client do
             end
 
             it 'makes no further attempts to any fallback hosts' do
-              expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeoutError
+              expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeout
               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
@@ -207,6 +307,52 @@ describe Ably::Rest::Client do
             expect(second_fallback_request_stub).to have_been_requested
           end
         end
+
+        context 'and basic authentication fails' do
+          let(:status) { 401 }
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return(
+              headers: { 'Content-Type' => 'application/json' },
+              status: status,
+              body: {
+	              "error" => {
+		              "statusCode" => 401,
+		              "code" => 40101,
+		              "message" => "Invalid credentials"
+	              }
+              }.to_json
+            )
+          end
+
+          it 'does not attempt the fallback hosts as this is an authentication failure' do
+            expect { publish_block.call }.to raise_error(Ably::Exceptions::InvalidRequest)
+            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
+
+        context 'and server returns a 50x error' do
+          let(:status) { 502 }
+          let(:fallback_block) do
+            Proc.new do
+              {
+                headers: { 'Content-Type' => 'text/html' },
+                status: status
+              }
+            end
+          end
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
+          end
+
+          it 'attempts the fallback hosts as this is an authentication failure' do
+            expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
+            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
 
@@ -253,7 +399,7 @@ describe Ably::Rest::Client do
         end
 
         it 'fails immediately and raises a Faraday Error' do
-          expect { client.auth.request_token }.to raise_error Ably::Exceptions::ConnectionTimeoutError
+          expect { client.auth.request_token }.to raise_error Ably::Exceptions::ConnectionTimeout
         end
 
         context 'fallback hosts' do
@@ -266,11 +412,27 @@ describe Ably::Rest::Client do
           end
 
           specify 'are never used' do
-            expect { client.auth.request_token }.to raise_error Ably::Exceptions::ConnectionTimeoutError
+            expect { client.auth.request_token }.to raise_error Ably::Exceptions::ConnectionTimeout
             expect(custom_host_request_stub).to have_been_requested
           end
         end
       end
     end
+
+    context '#auth' do
+      let(:dummy_auth_url) { 'http://dummy.url' }
+      let(:unique_ttl)     { 1234 }
+      let(:client_options) { default_options.merge(auth_url: dummy_auth_url, ttl: unique_ttl) }
+
+
+      it 'is provides access to the Auth object' do
+        expect(client.auth).to be_kind_of(Ably::Auth)
+      end
+
+      it 'configures the Auth object with all ClientOptions passed to client in the initializer' do
+        expect(client.auth.options[:ttl]).to eql(unique_ttl)
+        expect(client.auth.options[:auth_url]).to eql(dummy_auth_url)
+      end
+    end
   end
 end