ably-rest 0.7.5 → 0.8.1

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(api_key: 'appid.keyuid:keysecret'))
+      Ably::Rest::Client.new(client_options.merge(key: 'appid.keyuid:keysecret'))
     end
 
     let(:now) { Time.now - 1000 }
@@ -67,13 +67,13 @@ describe Ably::Rest do
 
   vary_by_protocol do
     let(:client) do
-      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      Ably::Rest::Client.new(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)
+          invalid_client = Ably::Rest::Client.new(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/)
@@ -109,18 +109,18 @@ describe Ably::Rest do
     end
 
     describe 'token authentication failures', :webmock do
-      let(:token_1) { { id: random_str } }
-      let(:token_2) { { id: random_str } }
-      let(:channel) { 'channelname' }
+      let(:token_1) { { token: random_str } }
+      let(:token_2) { { token: random_str } }
+      let(:channel) { random_str }
 
       before do
         @token_requests = 0
         @publish_attempts = 0
 
-        stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").to_return do
+        stub_request(:post, "#{client.endpoint}/keys/#{key_name}/requestToken").to_return do
           @token_requests += 1
           {
-            :body => { access_token: send("token_#{@token_requests}").merge(expires: Time.now.to_i + 3600) }.to_json,
+            :body => public_send("token_#{@token_requests}").merge(expires: (Time.now.to_i + 60) * 1000).to_json,
             :headers => { 'Content-Type' => 'application/json' }
           }
         end
@@ -143,7 +143,9 @@ describe Ably::Rest do
         it 'should automatically reissue a token' do
           client.channel(channel).publish('evt', 'msg')
           expect(@publish_attempts).to eql(1)
+          expect(@token_requests).to eql(1)
 
+          # Triggers an authentication 401 failure which should automatically request a new token
           client.channel(channel).publish('evt', 'msg')
           expect(@publish_attempts).to eql(3)
           expect(@token_requests).to eql(2)
@@ -151,7 +153,7 @@ describe Ably::Rest do
       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) }
+        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
           client.channel(channel).publish('evt', 'msg')

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

@@ -6,7 +6,7 @@ describe Ably::Rest::Channel do
 
   vary_by_protocol do
     let(:client) do
-      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
 
     describe '#publish' do
@@ -14,7 +14,7 @@ describe Ably::Rest::Channel do
       let(:event)   { 'foo' }
       let(:message) { 'woop!' }
 
-      it 'should publish the message adn return true indicating success' do
+      it 'should publish the message and return true indicating success' do
         expect(channel.publish(event, message)).to eql(true)
       end
     end
@@ -37,20 +37,20 @@ describe Ably::Rest::Channel do
       end
 
       it 'should return the current message history for the channel' do
-        actual_history = channel.history
+        actual_history_items = channel.history.items
 
-        expect(actual_history.size).to eql(3)
+        expect(actual_history_items.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 }
+          matching_message = actual_history_items.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|
+          channel.history.items.each do |message|
             expect(before_published.to_f).to be < message.timestamp.to_f
           end
         end
@@ -58,7 +58,7 @@ describe Ably::Rest::Channel do
 
       context 'message IDs' do
         it 'should be unique' do
-          message_ids = channel.history.map(&:id).compact
+          message_ids = channel.history.items.map(&:id).compact
           expect(message_ids.count).to eql(3)
           expect(message_ids.uniq.count).to eql(3)
         end
@@ -66,25 +66,25 @@ describe Ably::Rest::Channel do
 
       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
+        page_2 = page_1.next
+        page_3 = page_2.next
 
-        all_items = [page_1[0].id, page_2[0].id, page_3[0].id]
+        all_items = [page_1.items[0].id, page_2.items[0].id, page_3.items[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
+        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.size).to eql(1)
-        expect(page_2).to_not be_last_page
-        expect(page_2).to_not be_first_page
+        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.size).to eql(1)
-        expect(page_3).to be_last_page
-        expect(page_3).to_not be_first_page
+        expect(page_3.items.size).to eql(1)
+        expect(page_3).to be_last
+        expect(page_3).to_not be_first
       end
     end
 
@@ -93,15 +93,22 @@ describe Ably::Rest::Channel do
       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.user = key_name
           client_end_point.password = key_secret
         end
       end
+      let(:default_options) do
+          {
+            direction: :backwards,
+            limit: 100
+          }
+        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}").
+            query_params = default_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' })
           }
 

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

@@ -15,7 +15,7 @@ describe Ably::Rest::Channels do
 
   vary_by_protocol do
     let(:client) do
-      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
     let(:channel_name) { random_str }
     let(:options)      { { key: 'value' } }

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

@@ -12,14 +12,14 @@ describe Ably::Rest::Client do
 
     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) }
+      let(:token_request) { client.auth.create_token_request(key_name: key_name, key_secret: key_secret, client_id: client_id) }
 
-      context 'with an auth block' do
-        let(:client) { Ably::Rest::Client.new(client_options) { token_request } }
+      context 'with a :auth_callback Proc' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new { 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)
+        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
       end
 
@@ -32,54 +32,57 @@ describe Ably::Rest::Client do
         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)
+          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 'using tokens' do
       let(:client) do
-        Ably::Rest::Client.new(client_options) do
+        Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new do
           @request_index ||= 0
           @request_index += 1
-          send("token_request_#{@request_index}")
-        end
+          send("token_request_#{@request_index > 2 ? 'next' : @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)) }
 
+      # If token expires against whilst runnig tests in a slower CI environment then use this token
+      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_id: key_id, key_secret: key_secret, ttl: Ably::Models::Token::TOKEN_EXPIRY_BUFFER } }
+        let(:token_request_options) { { key_name: key_name, key_secret: key_secret, 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 }
-          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
+          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(token_request_1.client_id)
 
           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'])
+          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(token_request_2.client_id)
         end
       end
 
       context 'when token has not expired' do
-        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: 3600 } }
+        let(:token_request_options) { { key_name: key_name, 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'])
+          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(token_request_1.client_id)
 
           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'])
+          expect { client.channel('channel_name').publish('event', 'message') }.to_not change { client.auth.current_token_details }
+          expect(client.auth.current_token_details.client_id).to eql(token_request_1.client_id)
         end
       end
     end
 
     context 'connection transport' do
-      let(:client_options) { default_options.merge(api_key: api_key) }
+      let(:client_options) { default_options.merge(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
@@ -107,7 +110,7 @@ describe Ably::Rest::Client do
       let(:publish_block)  { proc { client.channel('test').publish('event', 'data') } }
 
       context 'configured' do
-        let(:client_options) { default_options.merge(api_key: api_key) }
+        let(:client_options) { default_options.merge(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 = []
@@ -119,7 +122,7 @@ describe Ably::Rest::Client do
       end
 
       context 'when environment is NOT production' do
-        let(:client_options) { default_options.merge(environment: 'sandbox', api_key: api_key) }
+        let(:client_options) { default_options.merge(environment: 'sandbox', 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')
@@ -135,7 +138,7 @@ describe Ably::Rest::Client 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) }
+        let(:client_options)     { default_options.merge(environment: nil, key: api_key) }
 
         before do
           stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
@@ -209,7 +212,7 @@ describe Ably::Rest::Client do
 
     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(:client_options) { default_options.merge(key: api_key, rest_host: custom_host) }
       let(:capability)     { { :foo => ["publish"] } }
 
       context 'that does not exist' do
@@ -242,7 +245,7 @@ describe Ably::Rest::Client do
       end
 
       context 'that times out', :webmock do
-        let(:path) { '/keys/app_id.key_id/requestToken' }
+        let(:path) { '/keys/app_id.key_name/requestToken' }
         let!(:custom_host_request_stub) do
           stub_request(:post, "https://#{custom_host}#{path}").to_return do
             raise Faraday::TimeoutError.new('timeout error message')

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'base64'
 
 describe Ably::Models::MessageEncoders do
-  let(:default_client_options) { { api_key: api_key, environment: environment } }
+  let(:default_client_options) { { key: api_key, environment: environment } }
   let(:client)                 { Ably::Rest::Client.new(default_client_options.merge(protocol: protocol)) }
   let(:channel_options)        { {} }
   let(:channel)                { client.channel('test', channel_options) }

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

@@ -6,7 +6,7 @@ describe Ably::Rest::Channel, 'messages' do
   include Ably::Modules::Conversions
 
   vary_by_protocol do
-    let(:default_client_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+    let(:default_client_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options)         { default_client_options }
     let(:client)                 { Ably::Rest::Client.new(client_options) }
     let(:other_client)           { Ably::Rest::Client.new(client_options) }
@@ -17,7 +17,7 @@ describe Ably::Rest::Channel, 'messages' do
 
       it 'is converted into UTF_8' do
         channel.publish message_name, 'example'
-        message = channel.history.first
+        message = channel.history.items.first
         expect(message.name.encoding).to eql(Encoding::UTF_8)
         expect(message.name.encode(Encoding::ASCII_8BIT)).to eql(message_name)
       end
@@ -80,13 +80,13 @@ describe Ably::Rest::Channel, 'messages' do
           it 'sends and retrieves messages that are encrypted & decrypted by the Ably library' do
             encrypted_channel.publish 'example', encoded_data_decoded
 
-            message = encrypted_channel.history.first
+            message = encrypted_channel.history.items.first
             expect(message.data).to eql(encoded_data_decoded)
             expect(message.encoding).to be_nil
           end
         end
 
-        resources_root = File.expand_path('../../../resources', __FILE__)
+        resources_root = File.expand_path('../../../../lib/submodules/ably-common/test-resources', __FILE__)
 
         def self.add_tests_for_data(data)
           data['items'].each_with_index do |item, index|
@@ -115,7 +115,7 @@ describe Ably::Rest::Channel, 'messages' do
               encrypted_channel.publish index.to_s, "#{index}-#{data}"
             end
 
-            messages = encrypted_channel.history
+            messages = encrypted_channel.history.items
 
             expect(messages.count).to eql(message_count)
             messages.each do |message|
@@ -140,7 +140,7 @@ describe Ably::Rest::Channel, 'messages' do
             specify "delivers a #{payload_description} payload to the receiver" do
               encrypted_channel.publish 'example', payload
 
-              message = other_client_channel.history.first
+              message = other_client_channel.history.items.first
               expect(message.data).to eql(payload)
               expect(message.encoding).to be_nil
             end
@@ -156,7 +156,7 @@ describe Ably::Rest::Channel, 'messages' do
           it 'does not attempt to decrypt the message' do
             unencrypted_channel.publish 'example', payload
 
-            message = other_client_encrypted_channel.history.first
+            message = other_client_encrypted_channel.history.items.first
             expect(message.data).to eql(payload)
             expect(message.encoding).to be_nil
           end
@@ -175,7 +175,7 @@ describe Ably::Rest::Channel, 'messages' do
           end
 
           it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
-            message = other_client_unencrypted_channel.history.first
+            message = other_client_unencrypted_channel.history.items.first
             expect(message.data).to_not eql(payload)
             expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
           end
@@ -202,7 +202,7 @@ describe Ably::Rest::Channel, 'messages' do
           end
 
           it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
-            message = encrypted_channel_client2.history.first
+            message = encrypted_channel_client2.history.items.first
             expect(message.data).to_not eql(payload)
             expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
           end
@@ -229,7 +229,7 @@ describe Ably::Rest::Channel, 'messages' do
           end
 
           it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
-            message = encrypted_channel_client2.history.first
+            message = encrypted_channel_client2.history.items.first
             expect(message.data).to_not eql(payload)
             expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
           end

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

@@ -5,7 +5,7 @@ describe Ably::Rest::Presence do
   include Ably::Modules::Conversions
 
   vary_by_protocol do
-    let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options) { default_options }
     let(:client) do
       Ably::Rest::Client.new(client_options)
@@ -16,88 +16,93 @@ describe Ably::Rest::Presence do
         IdiomaticRubyWrapper(fixture, stop_at: [:data])
       end
     end
+    let(:non_encoded_fixtures) { fixtures.reject { |fixture| fixture['encoding'] } }
+
+    # Encrypted fixtures need encryption details or an error will be raised
+    let(:cipher_details)   { TestApp::APP_SPEC_CIPHER }
+    let(:algorithm)        { cipher_details.fetch('algorithm').upcase }
+    let(:mode)             { cipher_details.fetch('mode').upcase }
+    let(:key_length)       { cipher_details.fetch('keylength') }
+    let(:secret_key)       { Base64.decode64(cipher_details.fetch('key')) }
+    let(:iv)               { Base64.decode64(cipher_details.fetch('iv')) }
+
+    let(:cipher_options)   { { key: secret_key, algorithm: algorithm, mode: mode, key_length: key_length, iv: iv } }
+    let(:fixtures_channel) { client.channel('persisted:presence_fixtures', encrypted: true, cipher_params: cipher_options, iv: iv) }
 
     context 'tested against presence fixture data set up in test app' do
-      describe '#get' do
-        before(:context) do
-          # When this test is run as a part of a test suite, the presence data injected in the test app may have expired
-          reload_test_app
-        end
+      before(:context) do
+        # When this test is run as a part of a test suite, the presence data injected in the test app may have expired
+        reload_test_app
+      end
 
-        let(:channel) { client.channel('persisted:presence_fixtures') }
-        let(:presence) { channel.presence.get }
+      describe '#get' do
+        let(:presence_page) { fixtures_channel.presence.get }
 
         it 'returns current members on the channel with their action set to :present' do
-          expect(presence.size).to eql(4)
+          expect(presence_page.items.size).to eql(fixtures.count)
 
-          fixtures.each do |fixture|
-            presence_message = presence.find { |client| client.client_id == fixture[:client_id] }
+          non_encoded_fixtures.each do |fixture|
+            presence_message = presence_page.items.find { |client| client.client_id == fixture[:client_id] }
             expect(presence_message.data).to eq(fixture[:data])
             expect(presence_message.action).to eq(:present)
           end
         end
 
         context 'with :limit option' do
-          let(:page_size) { 2 }
-          let(:presence)  { channel.presence.get(limit: page_size) }
+          let(:page_size) { 3 }
+          let(:presence_page)  { fixtures_channel.presence.get(limit: page_size) }
 
           it 'returns a paged response limiting number of members per page' do
-            expect(presence.size).to eql(2)
-            next_page = presence.next_page
-            expect(next_page.size).to eql(2)
-            expect(next_page).to be_last_page
+            expect(presence_page.items.size).to eql(page_size)
+            next_page = presence_page.next
+            expect(next_page.items.size).to eql(page_size)
+            expect(next_page).to be_last
           end
         end
       end
 
       describe '#history' do
-        before(:context) do
-          # When this test is run as a part of a test suite, the presence data injected in the test app may have expired
-          reload_test_app
-        end
-
-        let(:channel) { client.channel('persisted:presence_fixtures') }
-        let(:presence_history) { channel.presence.history }
+        let(:history_page) { fixtures_channel.presence.history }
 
         it 'returns recent presence activity' do
-          expect(presence_history.size).to eql(4)
+          expect(history_page.items.size).to eql(fixtures.count)
 
-          fixtures.each do |fixture|
-            presence_message = presence_history.find { |client| client.client_id == fixture['clientId'] }
+          non_encoded_fixtures.each do |fixture|
+            presence_message = history_page.items.find { |client| client.client_id == fixture['clientId'] }
             expect(presence_message.data).to eq(fixture[:data])
           end
         end
 
         context 'with options' do
-          let(:page_size) { 2 }
+          let(:page_size) { 3 }
 
           context 'direction: :forwards' do
-            let(:presence_history) { channel.presence.history(direction: :forwards) }
-            let(:paged_history_forward) { channel.presence.history(limit: page_size, direction: :forwards) }
+            let(:history_page) { fixtures_channel.presence.history(direction: :forwards) }
+            let(:paged_history_forward) { fixtures_channel.presence.history(limit: page_size, direction: :forwards) }
 
             it 'returns recent presence activity forwards with most recent history last' do
               expect(paged_history_forward).to be_a(Ably::Models::PaginatedResource)
-              expect(paged_history_forward.size).to eql(2)
+              expect(paged_history_forward.items.size).to eql(page_size)
 
-              next_page = paged_history_forward.next_page
+              next_page = paged_history_forward.next
 
-              expect(paged_history_forward.first.id).to eql(presence_history.first.id)
-              expect(next_page.first.id).to eql(presence_history[page_size].id)
+              expect(paged_history_forward.items.first.id).to eql(history_page.items.first.id)
+              expect(next_page.items.first.id).to eql(history_page.items[page_size].id)
             end
           end
 
           context 'direction: :backwards' do
-            let(:presence_history) { channel.presence.history(direction: :backwards) }
-            let(:paged_history_backward) { channel.presence.history(limit: page_size, direction: :backwards) }
+            let(:history_page) { fixtures_channel.presence.history(direction: :backwards) }
+            let(:paged_history_backward) { fixtures_channel.presence.history(limit: page_size, direction: :backwards) }
 
             it 'returns recent presence activity backwards with most recent history first' do
               expect(paged_history_backward).to be_a(Ably::Models::PaginatedResource)
-              expect(paged_history_backward.size).to eql(2)
+              expect(paged_history_backward.items.size).to eql(page_size)
 
-              next_page = paged_history_backward.next_page
+              next_page = paged_history_backward.next
 
-              expect(paged_history_backward.first.id).to eql(presence_history.first.id)
-              expect(next_page.first.id).to eql(presence_history[page_size].id)
+              expect(paged_history_backward.items.first.id).to eql(history_page.items.first.id)
+              expect(next_page.items.first.id).to eql(history_page.items[page_size].id)
             end
           end
         end
@@ -117,13 +122,20 @@ describe Ably::Rest::Presence do
           end
         end
         let(:client) do
-          Ably::Rest::Client.new(api_key: "#{user}:#{secret}")
+          Ably::Rest::Client.new(key: "#{user}:#{secret}")
+        end
+        let(:default_options) do
+          {
+            direction: :backwards,
+            limit: 100
+          }
         end
 
         [:start, :end].each do |option|
           describe ":#{option}", :webmock do
             let!(:history_stub) {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{option}=#{milliseconds}").
+              query_params = default_options.merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
+              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{query_params}").
                 to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
             }
 
@@ -154,7 +166,32 @@ describe Ably::Rest::Presence do
       end
     end
 
-    describe 'decoding', :webmock do
+    describe 'decoding' do
+      context 'with encoded fixture data' do
+        let(:decoded_client_id) { 'client_decoded' }
+        let(:encoded_client_id) { 'client_encoded' }
+
+        def message(client_id, messages)
+          messages.items.find { |message| message.client_id == client_id }
+        end
+
+        describe '#history' do
+          let(:history) { fixtures_channel.presence.history }
+          it 'decodes encoded and encryped presence fixture data automatically' do
+            expect(message(decoded_client_id, history).data).to eql(message(encoded_client_id, history).data)
+          end
+        end
+
+        describe '#get' do
+          let(:present) { fixtures_channel.presence.get }
+          it 'decodes encoded and encryped presence fixture data automatically' do
+            expect(message(decoded_client_id, present).data).to eql(message(encoded_client_id, present).data)
+          end
+        end
+      end
+    end
+
+    describe 'decoding permutations using mocked #history', :webmock do
       let(:user) { 'appid.keyuid' }
       let(:secret) { random_str(8) }
       let(:endpoint) do
@@ -164,7 +201,7 @@ describe Ably::Rest::Presence do
         end
       end
       let(:client) do
-        Ably::Rest::Client.new(client_options.merge(api_key: "#{user}:#{secret}"))
+        Ably::Rest::Client.new(client_options.merge(key: "#{user}:#{secret}"))
       end
 
       let(:data)            { random_str(32) }
@@ -195,7 +232,7 @@ describe Ably::Rest::Presence do
 
         context '#get' do
           let!(:get_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence?limit=100").
               to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
           }
 
@@ -204,15 +241,15 @@ describe Ably::Rest::Presence do
           end
 
           it 'automaticaly decodes presence messages' do
-            present = presence.get
-            expect(present.first.encoding).to be_nil
-            expect(present.first.data).to eql(data)
+            present_page = presence.get
+            expect(present_page.items.first.encoding).to be_nil
+            expect(present_page.items.first.data).to eql(data)
           end
         end
 
         context '#history' do
           let!(:history_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?direction=backwards&limit=100").
               to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
           }
 
@@ -221,9 +258,9 @@ describe Ably::Rest::Presence do
           end
 
           it 'automaticaly decodes presence messages' do
-            history = presence.history
-            expect(history.first.encoding).to be_nil
-            expect(history.first.data).to eql(data)
+            history_page = presence.history
+            expect(history_page.items.first.encoding).to be_nil
+            expect(history_page.items.first.data).to eql(data)
           end
         end
       end
@@ -242,10 +279,10 @@ describe Ably::Rest::Presence do
         context '#get' do
           let(:client_options) { default_options.merge(log_level: :fatal) }
           let!(:get_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence?limit=100").
               to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
           }
-          let(:presence_message) { presence.get.first }
+          let(:presence_message) { presence.get.items.first }
 
           after do
             expect(get_stub).to have_been_requested
@@ -266,10 +303,10 @@ describe Ably::Rest::Presence do
         context '#history' do
           let(:client_options) { default_options.merge(log_level: :fatal) }
           let!(:history_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?direction=backwards&limit=100").
               to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
           }
-          let(:presence_message) { presence.history.first }
+          let(:presence_message) { presence.history.items.first }
 
           after do
             expect(history_stub).to have_been_requested