ably 0.7.5 → 0.7.6

data/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/spec/acceptance/rest/client_spec.rb

@@ -43,12 +43,15 @@ describe Ably::Rest::Client do
         Ably::Rest::Client.new(client_options) do
           @request_index ||= 0
           @request_index += 1
-          send("token_request_#{@request_index}")
+          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 } }
 
@@ -79,7 +82,7 @@ describe Ably::Rest::Client do
     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

data/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/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/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,7 +122,7 @@ 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
 
         [:start, :end].each do |option|
@@ -154,7 +159,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 +194,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) }
@@ -204,9 +234,9 @@ 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
 
@@ -221,9 +251,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
@@ -245,7 +275,7 @@ describe Ably::Rest::Presence do
             stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
               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
@@ -269,7 +299,7 @@ describe Ably::Rest::Presence do
             stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history").
               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

data/spec/acceptance/rest/stats_spec.rb

@@ -9,17 +9,17 @@ describe Ably::Rest::Client, '#stats' do
 
   STATS_FIXTURES = [
     {
-      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL - 120, :minute),
+      intervalId: Ably::Models::Stats.to_interval_id(LAST_INTERVAL - 120, :minute),
       inbound:  { realtime: { messages: { count: 50, data: 5000 } } },
       outbound: { realtime: { messages: { count: 20, data: 2000 } } }
     },
     {
-      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL - 60, :minute),
+      intervalId: Ably::Models::Stats.to_interval_id(LAST_INTERVAL - 60, :minute),
       inbound:  { realtime: { messages: { count: 60, data: 6000 } } },
       outbound: { realtime: { messages: { count: 10, data: 1000 } } }
     },
     {
-      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL, :minute),
+      intervalId: Ably::Models::Stats.to_interval_id(LAST_INTERVAL, :minute),
       inbound:       { realtime: { messages: { count: 70, data: 7000 } } },
       outbound:      { realtime: { messages: { count: 40, data: 4000 } } },
       persisted:     { presence: { count: 20, data: 2000 } },
@@ -36,7 +36,7 @@ describe Ably::Rest::Client, '#stats' do
   end
 
   vary_by_protocol do
-    let(:client) {  Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol) }
+    let(:client) {  Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol) }
 
     describe 'fetching application stats' do
       context 'by minute' do
@@ -45,55 +45,60 @@ describe Ably::Rest::Client, '#stats' do
 
         context 'with :from set to last interval and :limit set to 1' do
           let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), by: :minute, limit: 1) }
-          let(:stat)    { subject.first}
+          let(:stat)    { subject.items.first }
 
           it 'retrieves only one stat' do
-            expect(subject.count).to eql(1)
+            expect(subject.items.count).to eql(1)
+          end
+
+          it 'returns zero value for any missing metrics' do
+            expect(stat.channels.refused).to eql(0)
+            expect(stat.outbound.webhook.all.count).to eql(0)
           end
 
           it 'returns all aggregated message data' do
-            expect(stat.all[:messages][:count]).to eql(70 + 40) # inbound + outbound
-            expect(stat.all[:messages][:data]).to eql(7000 + 4000) # inbound + outbound
+            expect(stat.all.messages.count).to eql(70 + 40) # inbound + outbound
+            expect(stat.all.messages.data).to eql(7000 + 4000) # inbound + outbound
           end
 
           it 'returns inbound realtime all data' do
-            expect(stat.inbound[:realtime][:all][:count]).to eql(70)
-            expect(stat.inbound[:realtime][:all][:data]).to eql(7000)
+            expect(stat.inbound.realtime.all.count).to eql(70)
+            expect(stat.inbound.realtime.all.data).to eql(7000)
           end
 
           it 'returns inbound realtime message data' do
-            expect(stat.inbound[:realtime][:messages][:count]).to eql(70)
-            expect(stat.inbound[:realtime][:messages][:data]).to eql(7000)
+            expect(stat.inbound.realtime.messages.count).to eql(70)
+            expect(stat.inbound.realtime.messages.data).to eql(7000)
           end
 
           it 'returns outbound realtime all data' do
-            expect(stat.outbound[:realtime][:all][:count]).to eql(40)
-            expect(stat.outbound[:realtime][:all][:data]).to eql(4000)
+            expect(stat.outbound.realtime.all.count).to eql(40)
+            expect(stat.outbound.realtime.all.data).to eql(4000)
           end
 
           it 'returns persisted presence all data' do
-            expect(stat.persisted[:all][:count]).to eql(20)
-            expect(stat.persisted[:all][:data]).to eql(2000)
+            expect(stat.persisted.all.count).to eql(20)
+            expect(stat.persisted.all.data).to eql(2000)
           end
 
           it 'returns connections all data' do
-            expect(stat.connections[:tls][:peak]).to eql(20)
-            expect(stat.connections[:tls][:opened]).to eql(10)
+            expect(stat.connections.tls.peak).to eql(20)
+            expect(stat.connections.tls.opened).to eql(10)
           end
 
           it 'returns channels all data' do
-            expect(stat.channels[:peak]).to eql(50)
-            expect(stat.channels[:opened]).to eql(30)
+            expect(stat.channels.peak).to eql(50)
+            expect(stat.channels.opened).to eql(30)
           end
 
           it 'returns api_requests data' do
-            expect(stat.api_requests[:succeeded]).to eql(50)
-            expect(stat.api_requests[:failed]).to eql(10)
+            expect(stat.api_requests.succeeded).to eql(50)
+            expect(stat.api_requests.failed).to eql(10)
           end
 
           it 'returns token_requests data' do
-            expect(stat.token_requests[:succeeded]).to eql(60)
-            expect(stat.token_requests[:failed]).to eql(20)
+            expect(stat.token_requests.succeeded).to eql(60)
+            expect(stat.token_requests.failed).to eql(20)
           end
 
           it 'returns stat objects with #interval_granularity equal to :minute' do
@@ -112,34 +117,34 @@ describe Ably::Rest::Client, '#stats' do
         context 'with :start set to first interval, :limit set to 1 and direction :forwards' do
           let(:first_interval) { LAST_INTERVAL - 120 }
           let(:subject)        { client.stats(start: as_since_epoch(first_interval), by: :minute, direction: :forwards, limit: 1) }
-          let(:stat)           { subject.first}
+          let(:stat)           { subject.items.first }
 
           it 'returns the first interval stats as stats are provided forwards from :start' do
-            expect(stat.inbound[:realtime][:all][:count]).to eql(first_inbound_realtime_count)
+            expect(stat.inbound.realtime.all.count).to eql(first_inbound_realtime_count)
           end
 
           it 'returns 3 pages of stats' do
-            expect(subject).to be_first_page
-            expect(subject).to_not be_last_page
-            page3 = subject.next_page.next_page
-            expect(page3).to be_last_page
-            expect(page3.first.inbound[:realtime][:all][:count]).to eql(last_inbound_realtime_count)
+            expect(subject).to be_first
+            expect(subject).to_not be_last
+            page3 = subject.next.next
+            expect(page3).to be_last
+            expect(page3.items.first.inbound.realtime.all.count).to eql(last_inbound_realtime_count)
           end
         end
 
         context 'with :end set to last interval, :limit set to 1 and direction :backwards' do
           let(:subject)        { client.stats(:end => as_since_epoch(LAST_INTERVAL), by: :minute, direction: :backwards, limit: 1) }
-          let(:stat)           { subject.first}
+          let(:stat)           { subject.items.first }
 
           it 'returns the 3rd interval stats first as stats are provided backwards from :end' do
-            expect(stat.inbound[:realtime][:all][:count]).to eql(last_inbound_realtime_count)
+            expect(stat.inbound.realtime.all.count).to eql(last_inbound_realtime_count)
           end
 
           it 'returns 3 pages of stats' do
-            expect(subject).to be_first_page
-            expect(subject).to_not be_last_page
-            page3 = subject.next_page.next_page
-            expect(page3.first.inbound[:realtime][:all][:count]).to eql(first_inbound_realtime_count)
+            expect(subject).to be_first
+            expect(subject).to_not be_last
+            page3 = subject.next.next
+            expect(page3.items.first.inbound.realtime.all.count).to eql(first_inbound_realtime_count)
           end
         end
       end
@@ -147,7 +152,7 @@ describe Ably::Rest::Client, '#stats' do
       [:hour, :day, :month].each do |interval|
         context "by #{interval}" do
           let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), by: interval, direction: 'forwards', limit: 1) }
-          let(:stat)    { subject.first }
+          let(:stat)    { subject.items.first }
           let(:aggregate_messages_count) do
             STATS_FIXTURES.inject(0) do |sum, fixture|
               sum + fixture[:inbound][:realtime][:messages][:count] + fixture[:outbound][:realtime][:messages][:count]
@@ -160,10 +165,10 @@ describe Ably::Rest::Client, '#stats' do
           end
 
           it 'should aggregate the stats for that period' do
-            expect(subject.count).to eql(1)
+            expect(subject.items.count).to eql(1)
 
-            expect(stat.all[:messages][:count]).to eql(aggregate_messages_count)
-            expect(stat.all[:messages][:data]).to eql(aggregate_messages_data)
+            expect(stat.all.messages.count).to eql(aggregate_messages_count)
+            expect(stat.all.messages.data).to eql(aggregate_messages_data)
           end
         end
       end