ably 0.7.5 → 0.7.6

data/spec/acceptance/realtime/client_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe Ably::Realtime::Client, :event_machine do
   vary_by_protocol do
     let(:default_options) do
-      { api_key: api_key, environment: environment, protocol: protocol }
+      { key: api_key, environment: environment, protocol: protocol }
     end
 
     let(:client_options) { default_options }
@@ -15,7 +15,7 @@ describe Ably::Realtime::Client, :event_machine do
 
     context 'initialization' do
       context 'basic auth' do
-        it 'is enabled by default with a provided :api_key option' do
+        it 'is enabled by default with a provided :key option' do
           connection.on(:connected) do
             expect(auth_params[:key_id]).to_not be_nil
             expect(auth_params[:access_token]).to be_nil
@@ -58,7 +58,7 @@ describe Ably::Realtime::Client, :event_machine do
               end
             end
 
-            context 'with valid :api_key and :use_token_auth option set to true' do
+            context 'with valid :key and :use_token_auth option set to true' do
               let(:client_options)  { default_options.merge(use_token_auth: true) }
 
               it 'automatically authorises on connect and generates a token' do

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -6,7 +6,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
   vary_by_protocol do
     let(:default_options) do
-      { api_key: api_key, environment: environment, protocol: protocol }
+      { key: api_key, environment: environment, protocol: protocol }
     end
 
     let(:client_options) { default_options }
@@ -16,7 +16,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
     context 'authentication failure' do
       let(:client_options) do
-        default_options.merge(api_key: invalid_key, log_level: :none)
+        default_options.merge(key: invalid_key, log_level: :none)
       end
 
       context 'when API key is invalid' do

data/spec/acceptance/realtime/connection_spec.rb

@@ -7,7 +7,7 @@ describe Ably::Realtime::Connection, :event_machine do
 
   vary_by_protocol do
     let(:default_options) do
-      { api_key: api_key, environment: environment, protocol: protocol }
+      { key: api_key, environment: environment, protocol: protocol }
     end
 
     let(:client_options) { default_options }
@@ -138,11 +138,11 @@ describe Ably::Realtime::Connection, :event_machine do
 
             context 'when connected with a valid non-expired token' do
               context 'that then expires following the connection being opened' do
-                let(:ttl)     { 2 }
+                let(:ttl)     { 5 }
                 let(:channel) { client.channel('test') }
 
                 context 'the server' do
-                  it 'disconnects the client, and the client automatically renews the token and then reconnects', em_timeout: 10 do
+                  it 'disconnects the client, and the client automatically renews the token and then reconnects', em_timeout: 15 do
                     original_token = client.auth.current_token
                     expect(original_token).to_not be_expired
 
@@ -177,7 +177,7 @@ describe Ably::Realtime::Connection, :event_machine do
             end
 
             context 'opening a new connection' do
-              let(:client_options) { default_options.merge(api_key: nil, token_id: expired_token.id, log_level: :none) }
+              let(:client_options) { default_options.merge(key: nil, token_id: expired_token.id, log_level: :none) }
 
               it 'transitions state to failed', em_timeout: 10 do
                 EventMachine.add_timer(1) do # wait for token to expire

data/spec/acceptance/realtime/message_spec.rb

@@ -6,7 +6,7 @@ require 'securerandom'
 
 describe 'Ably::Realtime::Channel Message', :event_machine do
   vary_by_protocol do
-    let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
+    let(:default_options) { options.merge(key: api_key, environment: environment, protocol: protocol) }
     let(:client_options)  { default_options }
     let(:client) do
       Ably::Realtime::Client.new(client_options)
@@ -77,8 +77,8 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'when retrieved over REST' do
         it 'matches the sender connection#id' do
           channel.publish('event', payload) do
-            channel.history do |messages|
-              expect(messages.first.connection_id).to eql(client.connection.id)
+            channel.history do |page|
+              expect(page.items.first.connection_id).to eql(client.connection.id)
               stop_reactor
             end
           end
@@ -175,7 +175,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
     context 'without suitable publishing permissions' do
       let(:restricted_client) do
-        Ably::Realtime::Client.new(options.merge(api_key: restricted_api_key, environment: environment, protocol: protocol))
+        Ably::Realtime::Client.new(options.merge(key: restricted_api_key, environment: environment, protocol: protocol))
       end
       let(:restricted_channel) { restricted_client.channel("cansubscribe:example") }
       let(:payload)            { 'Test message without permission to publish' }
@@ -293,7 +293,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         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|

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 describe Ably::Realtime::Presence, 'history', :event_machine do
   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(:channel_name)        { "persisted:#{random_str(2)}" }
 
@@ -21,16 +21,16 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
     it 'provides up to the moment presence history' do
       presence_client_one.enter(data: data) do
         presence_client_one.leave(data: leave_data) do
-          presence_client_one.history do |history|
-            expect(history.count).to eql(2)
+          presence_client_one.history do |history_page|
+            expect(history_page.items.count).to eql(2)
 
-            expect(history[1].action).to eq(:enter)
-            expect(history[1].client_id).to eq(client_one.client_id)
-            expect(history[1].data).to eql(data)
+            expect(history_page.items[1].action).to eq(:enter)
+            expect(history_page.items[1].client_id).to eq(client_one.client_id)
+            expect(history_page.items[1].data).to eql(data)
 
-            expect(history[0].action).to eq(:leave)
-            expect(history[0].client_id).to eq(client_one.client_id)
-            expect(history[0].data).to eql(leave_data)
+            expect(history_page.items[0].action).to eq(:leave)
+            expect(history_page.items[0].client_id).to eq(client_one.client_id)
+            expect(history_page.items[0].data).to eql(leave_data)
 
             stop_reactor
           end
@@ -40,16 +40,59 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
     it 'ensures REST presence history message IDs match ProtocolMessage wrapped message and connection IDs via Realtime' do
       presence_client_one.subscribe(:enter) do |message|
-        presence_client_one.history do |history|
-          expect(history.count).to eql(1)
+        presence_client_one.history do |history_page|
+          expect(history_page.items.count).to eql(1)
 
-          expect(history[0].id).to eql(message.id)
-          expect(history[0].connection_id).to eql(message.connection_id)
+          expect(history_page.items[0].id).to eql(message.id)
+          expect(history_page.items[0].connection_id).to eql(message.connection_id)
           stop_reactor
         end
       end
 
       presence_client_one.enter(data: data)
     end
+
+    context 'with option until_attach: true' do
+      let(:event) { random_str }
+      let(:presence_data_before_attach) { random_str }
+      let(:presence_data_after_attach) { random_str }
+
+      it 'retrieves all presence messages before channel was attached' do
+        presence_client_two.enter(data: presence_data_before_attach) do
+          presence_client_one.enter(data: presence_data_after_attach) do
+            presence_client_one.history(until_attach: true) do |presence_page|
+              expect(presence_page.items.count).to eql(1)
+              expect(presence_page.items.first.data).to eql(presence_data_before_attach)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'and two pages of messages' do
+        it 'retrieves two pages of messages before channel was attached' do
+          when_all(*10.times.map { |i| presence_client_two.enter_client("client:#{i}", data: presence_data_before_attach) }) do
+            when_all(*10.times.map { |i| presence_client_one.enter_client("client:#{i}", data: presence_data_after_attach) }) do
+              presence_client_one.history(until_attach: true, limit: 5) do |presence_page|
+                expect(presence_page.items.count).to eql(5)
+                expect(presence_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
+
+                presence_page.next do |presence_next_page|
+                  expect(presence_next_page.items.count).to eql(5)
+                  expect(presence_next_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
+                  expect(presence_next_page).to be_last
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+
+      it 'raises an exception unless state is attached' do
+        expect { presence_client_one.history(until_attach: true) }.to raise_error(ArgumentError, /not attached/)
+        stop_reactor
+      end
+    end
   end
 end

data/spec/acceptance/realtime/presence_spec.rb

@@ -5,7 +5,7 @@ describe Ably::Realtime::Presence, :event_machine 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(:anonymous_client) { Ably::Realtime::Client.new(client_options) }
@@ -487,7 +487,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'without necessary capabilities to join presence' do
         let(:restricted_client) do
-          Ably::Realtime::Client.new(default_options.merge(api_key: restricted_api_key, log_level: :fatal))
+          Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
         end
         let(:restricted_channel)  { restricted_client.channel("cansubscribe:channel") }
         let(:restricted_presence) { restricted_channel.presence }
@@ -688,7 +688,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
         context 'without necessary capabilities to enter on behalf of another client' do
           let(:restricted_client) do
-            Ably::Realtime::Client.new(default_options.merge(api_key: restricted_api_key, log_level: :fatal))
+            Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
           end
           let(:restricted_channel)  { restricted_client.channel("cansubscribe:channel") }
           let(:restricted_presence) { restricted_channel.presence }
@@ -1123,8 +1123,8 @@ describe Ably::Realtime::Presence, :event_machine do
     context 'REST #get' do
       it 'returns current members' do
         presence_client_one.enter(data: data_payload) do
-          members = channel_rest_client_one.presence.get
-          this_member = members.first
+          members_page = channel_rest_client_one.presence.get
+          this_member = members_page.items.first
 
           expect(this_member).to be_a(Ably::Models::PresenceMessage)
           expect(this_member.client_id).to eql(client_one.client_id)
@@ -1137,8 +1137,8 @@ describe Ably::Realtime::Presence, :event_machine do
       it 'returns no members once left' do
         presence_client_one.enter(data: data_payload) do
           presence_client_one.leave do
-            members = channel_rest_client_one.presence.get
-            expect(members.count).to eql(0)
+            members_page = channel_rest_client_one.presence.get
+            expect(members_page.items.count).to eql(0)
             stop_reactor
           end
         end
@@ -1264,7 +1264,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'REST #get' do
         it 'returns a list of members with decrypted data' do
           encrypted_channel.presence.enter(data: data) do
-            member = channel_rest_client_one.presence.get.first
+            member = channel_rest_client_one.presence.get.items.first
             expect(member.encoding).to be_nil
             expect(member.data).to eql(data)
             stop_reactor

data/spec/acceptance/realtime/stats_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ably::Realtime::Client, '#stats', :event_machine do
   vary_by_protocol do
     let(:client) do
-      Ably::Realtime::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
 
     describe 'fetching stats' do

data/spec/acceptance/realtime/time_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ably::Realtime::Client, '#time', :event_machine do
   vary_by_protocol do
     let(:client) do
-      Ably::Realtime::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
 
     describe 'fetching the service time' do

data/spec/acceptance/rest/auth_spec.rb

@@ -23,7 +23,7 @@ describe Ably::Auth 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(:auth) { client.auth }
     let(:content_type) do
@@ -349,6 +349,15 @@ describe Ably::Auth do
           end
         end
       end
+
+      context 'with client_id' do
+        let(:client_id) { random_str }
+        let(:token) { auth.request_token(client_id: client_id) }
+
+        it 'returns a token with the client_id' do
+          expect(token.client_id).to eql(client_id)
+        end
+      end
     end
 
     context 'before #authorise has been called' do
@@ -587,7 +596,7 @@ describe Ably::Auth do
       context 'when implicit as a result of using :client id' do
         let(:client_id) { '999' }
         let(:client) do
-          Ably::Rest::Client.new(api_key: api_key, client_id: client_id, environment: environment, protocol: protocol)
+          Ably::Rest::Client.new(key: api_key, client_id: client_id, environment: environment, protocol: protocol)
         end
         let(:token_id) { 'unique-token-id' }
         let(:token_response) do
@@ -632,7 +641,7 @@ describe Ably::Auth do
             expect(token).to be_a(Ably::Models::Token)
             capability_with_str_key = Ably::Models::Token::DEFAULTS[:capability]
             capability = Hash[capability_with_str_key.keys.map(&:to_sym).zip(capability_with_str_key.values)]
-            expect(token.capability).to eq(capability)
+            expect(token.capability).to eq(JSON.dump(capability))
             expect(token.expires_at.to_i).to be_within(2).of(Time.now.to_i + Ably::Models::Token::DEFAULTS[:ttl])
             expect(token.client_id).to eq(client_id)
           end
@@ -640,14 +649,32 @@ describe Ably::Auth do
       end
     end
 
-    context 'when using an :api_key and basic auth' do
+    context 'when using an :key and basic auth' do
       specify '#using_token_auth? is false' do
         expect(auth).to_not be_using_token_auth
       end
 
+      specify '#key attribute contains the key string' do
+        expect(auth.key).to eql(api_key)
+      end
+
       specify '#using_basic_auth? is true' do
         expect(auth).to be_using_basic_auth
       end
     end
+
+    context 'when using legacy :api_key option and basic auth' do
+      let(:client) do
+        Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      end
+
+      specify '#using_token_auth? is false' do
+        expect(auth).to_not be_using_token_auth
+      end
+
+      specify '#key attribute contains the key string' do
+        expect(auth.key).to eql(api_key)
+      end
+    end
   end
 end

data/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/)

data/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