ably 1.0.5 → 1.0.6

data/spec/acceptance/realtime/connection_spec.rb

@@ -131,7 +131,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 let(:ttl) { 0.001 }
                 let(:auth_requests) { [] }
                 let(:token_callback) do
-                  Proc.new do
+                  lambda do |token_params|
                     auth_requests << Time.now
                     Ably::Rest::Client.new(default_options).auth.request_token(ttl: ttl).token
                   end
@@ -246,7 +246,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   let(:ttl)           { 4 }
                   let(:auth_requests) { [] }
                   let(:token_callback) do
-                    Proc.new do
+                    lambda do |token_params|
                       sleep 2
                       auth_requests << Time.now
                       Ably::Rest::Client.new(default_options).auth.request_token(ttl: ttl).token
@@ -298,7 +298,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 context 'and subsequent token is invalid' do
                   let(:ttl) { 2 }
                   let(:token_callback) do
-                    Proc.new do
+                    lambda do |token_params|
                       if @token_issued
                         "#{app_id}.invalid-token-invalid-token-invalid-token"
                       else
@@ -417,7 +417,7 @@ describe Ably::Realtime::Connection, :event_machine do
       let(:phases) { [:connecting, :connected] }
       let(:events_emitted) { [] }
       let(:test_expectation) do
-        Proc.new do
+        lambda do
           expect(events_emitted).to eq(phases)
           stop_reactor
         end
@@ -466,7 +466,7 @@ describe Ably::Realtime::Connection, :event_machine do
           been_disconnected = true
         end
         connection.once(:connecting) do
-          close_if_transport_available = proc do
+          close_if_transport_available = lambda do
             EventMachine.add_timer(0.001) do
               if connection.transport
                 connection.transport.close_connection_after_writing
@@ -796,7 +796,7 @@ describe Ably::Realtime::Connection, :event_machine do
             end
           end
 
-          ping_block = Proc.new do
+          ping_block = lambda do |time|
             pings_complete << true
             if pings_complete.length == 3
               expect(heartbeat_ids.uniq.length).to eql(3)
@@ -980,7 +980,6 @@ describe Ably::Realtime::Connection, :event_machine do
 
       context 'transport-level heartbeats are supported in the websocket transport' do
         it 'provides the heartbeats argument in the websocket connection params (#RTN23b)' do
-          skip 'Native heartbeats not yet supported in the WS driver https://github.com/ably/ably-ruby/issues/116'
           expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
             uri = URI.parse(url)
             expect(CGI::parse(uri.query)['heartbeats'][0]).to eql('false')
@@ -990,12 +989,10 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         it 'receives websocket heartbeat messages (#RTN23b) [slow test as need to wait for heartbeat]', em_timeout: 45 do
-          skip "Heartbeats param is missing from realtime implementation, see https://github.com/ably/realtime/issues/656"
-
           connection.once(:connected) do
             connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.action == :heartbeat
-                expect(protocol_message.attributes[:source]).to eql('websocket')
+                expect(protocol_message.attributes[:source]).to eql(:websocket)
                 expect(connection.time_since_connection_confirmed_alive?).to be_within(1).of(0)
                 stop_reactor
               end
@@ -1021,7 +1018,8 @@ describe Ably::Realtime::Connection, :event_machine do
           connection.once(:connected) do
             connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.action == :heartbeat
-                expect(protocol_message.attributes[:source]).to_not eql('websocket')
+                next if protocol_message.attributes[:source] == :websocket # ignore the native heartbeats
+                expect(protocol_message.attributes[:source]).to_not eql(:websocket)
                 expect(connection.time_since_connection_confirmed_alive?).to be_within(1).of(0)
                 stop_reactor
               end
@@ -1176,24 +1174,18 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       context "opening a new connection using a recently disconnected connection's #recovery_key" do
-        context 'connection#id and connection#key after recovery' do
-          it 'remains the same for id and party for key' do
-            connection_key_consistent_part_regex = /.*?!([\w-]{5,})-\w+/
+        context 'connection#id after recovery' do
+          it 'remains the same' do
             previous_connection_id  = nil
-            previous_connection_key = nil
 
             connection.once(:connected) do
               previous_connection_id  = connection.id
-              previous_connection_key = connection.key
               connection.transition_state_machine! :failed
             end
 
             connection.once(:failed) do
               recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on(:connected) do
-                expect(recover_client.connection.key[connection_key_consistent_part_regex, 1]).to_not be_nil
-                expect(recover_client.connection.key[connection_key_consistent_part_regex, 1]).to eql(
-                  previous_connection_key[connection_key_consistent_part_regex, 1])
                 expect(recover_client.connection.id).to eql(previous_connection_id)
                 stop_reactor
               end
@@ -1485,7 +1477,7 @@ describe Ably::Realtime::Connection, :event_machine do
               end
             end
 
-            close_connection_proc = Proc.new do
+            close_connection_proc = lambda do
               EventMachine.add_timer(0.001) do
                 if connection.transport.nil?
                   close_connection_proc.call
@@ -1523,7 +1515,7 @@ describe Ably::Realtime::Connection, :event_machine do
       # See https://github.com/ably/ably-ruby/issues/103
       it 'emits event to all and single subscribers' do
         connected_emitted = []
-        block = Proc.new do |state_change|
+        block = lambda do |state_change|
           if state_change.current == :connected
             connected_emitted << state_change
             EventMachine.add_timer(0.5) do

data/spec/acceptance/realtime/message_spec.rb

@@ -284,7 +284,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
 
       it 'sends and receives the messages on both opened connections and calls the success callbacks for each message published', em_timeout: 10 do
-        check_message_and_callback_counts = Proc.new do
+        check_message_and_callback_counts = lambda do
           if echos[:client] == expected_echos && echos[:other] == expected_echos
             # Wait for message backlog to clear
             EventMachine.add_timer(0.5) do
@@ -650,7 +650,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       let(:msgs_received)  { [] }
 
       it 'publishes the message again, later receives the ACK and only one message is ever received from Ably' do
-        on_reconnected = Proc.new do
+        on_reconnected = lambda do |*args|
           expect(message_state).to be_empty
           EventMachine.add_timer(2) do
             expect(message_state).to contain_exactly(:delivered)

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -71,11 +71,14 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
       end
 
       context 'and two pages of messages' do
-        let(:wildcard_token) { Proc.new { Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') } }
+        let(:wildcard_token) { lambda { |token_params| Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') } }
         let(:client_one)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
         let(:client_two)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
 
-        it 'retrieves two pages of messages before channel was attached' do
+        # TODO: Remove retry logic when presence history regression fixed
+        #       https://github.com/ably/realtime/issues/1707
+        #
+        it 'retrieves two pages of messages before channel was attached', retry: 10, :retry_wait => 5 do
           when_all(*10.times.map { |i| presence_client_two.enter_client("client:#{i}", presence_data_before_attach) }) do
             when_all(*10.times.map { |i| presence_client_one.enter_client("client:#{i}", presence_data_after_attach) }) do
               presence_client_one.history(until_attach: true, limit: 5) do |presence_page|
@@ -85,7 +88,13 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
                 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
+                  if presence_next_page.has_next?
+                    presence_next_page.next do |last|
+                      expect(last.items.count).to eql(0)
+                    end
+                  else
+                    expect(presence_next_page).to be_last
+                  end
                   stop_reactor
                 end
               end

data/spec/acceptance/realtime/presence_spec.rb

@@ -14,7 +14,7 @@ describe Ably::Realtime::Presence, :event_machine do
     let(:client_two_id)    { random_str }
     let(:client_two)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: client_two_id)) }
 
-    let(:wildcard_token)            { Proc.new { Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*') } }
+    let(:wildcard_token)            { lambda { |token_params| Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*') } }
     let(:channel_name)              { "presence-#{random_str(4)}" }
     let(:channel_anonymous_client)  { anonymous_client.channel(channel_name) }
     let(:presence_anonymous_client) { channel_anonymous_client.presence }
@@ -1354,7 +1354,7 @@ describe Ably::Realtime::Presence, :event_machine do
               clients << presence
               next unless clients.count == 5
 
-              wait_until(proc { updated_callback_count == 5 }) do
+              wait_until(lambda { updated_callback_count == 5 }) do
                 expect(clients.map(&:client_id).uniq.count).to eql(5)
                 expect(updated_callback_count).to eql(5)
                 stop_reactor
@@ -1388,7 +1388,7 @@ describe Ably::Realtime::Presence, :event_machine do
               clients << presence
               next unless clients.count == 5
 
-              wait_until(proc { updated_callback_count == 5 }) do
+              wait_until(lambda { updated_callback_count == 5 }) do
                 expect(clients.map(&:client_id).uniq.count).to eql(5)
                 expect(updated_callback_count).to eql(5)
                 stop_reactor
@@ -1420,7 +1420,7 @@ describe Ably::Realtime::Presence, :event_machine do
                 clients << presence
                 next unless clients.count == 5
 
-                wait_until(proc { left_callback_count == 5 }) do
+                wait_until(lambda { left_callback_count == 5 }) do
                   expect(clients.map(&:client_id).uniq.count).to eql(5)
                   expect(left_callback_count).to eql(5)
                   stop_reactor
@@ -1442,7 +1442,7 @@ describe Ably::Realtime::Presence, :event_machine do
                 clients << presence
                 next unless clients.count == 5
 
-                wait_until(proc { left_callback_count == 5 }) do
+                wait_until(lambda { left_callback_count == 5 }) do
                   expect(clients.map(&:client_id).uniq.count).to eql(5)
                   expect(left_callback_count).to eql(5)
                   stop_reactor
@@ -1789,7 +1789,7 @@ describe Ably::Realtime::Presence, :event_machine do
             clients_entered[:client_two] += 1
           end
 
-          wait_until(proc { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
+          wait_until(lambda { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
             presence_anonymous_client.get(wait_for_sync: true) do |anonymous_members|
               expect(anonymous_members.count).to eq(total_members)
               expect(anonymous_members.map(&:client_id).uniq.count).to eq(total_members)
@@ -1886,7 +1886,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with no arguments' do
         it 'removes the callback for all presence events' do
           when_all(channel_client_one.attach, channel_client_two.attach) do
-            subscribe_callback = proc { raise 'Should not be called' }
+            subscribe_callback = lambda { raise 'Should not be called' }
             presence_client_two.subscribe(&subscribe_callback)
             presence_client_two.unsubscribe(&subscribe_callback)
 
@@ -1904,7 +1904,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with event name' do
         it 'removes the callback for specified presence event' do
           when_all(channel_client_one.attach, channel_client_two.attach) do
-            subscribe_callback = proc { raise 'Should not be called' }
+            subscribe_callback = lambda { raise 'Should not be called' }
             presence_client_two.subscribe :leave, &subscribe_callback
             presence_client_two.unsubscribe :leave, &subscribe_callback
 
@@ -2337,7 +2337,7 @@ describe Ably::Realtime::Presence, :event_machine do
       let(:present_only_capability) do
         { channel_name => ["presence"] }
       end
-      let(:present_only_callback) { Proc.new { Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*', capability: present_only_capability) } }
+      let(:present_only_callback) { lambda { |token_params| Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*', capability: present_only_capability) } }
       let(:client_one) { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: present_only_callback)) }
 
       it 'receives presence updates for all presence events generated by the current connection and the presence map is kept up to date (#RTP17a)' do
@@ -2751,7 +2751,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'channel transitions to the SUSPENDED state' do
         let(:auth_callback) do
-          Proc.new do
+          lambda do |token_params|
             # Pause to allow presence updates to occur whilst disconnected
             sleep 1
             Ably::Rest::Client.new(client_options).auth.request_token

data/spec/acceptance/rest/auth_spec.rb

@@ -472,7 +472,7 @@ describe Ably::Auth do
           end
 
           let(:auth_callback) do
-            Proc.new do |token_params_arg|
+            lambda do |token_params_arg|
               @block_called = true
               @block_params = token_params_arg
               {
@@ -486,7 +486,7 @@ describe Ably::Auth do
             end
           end
 
-          it 'calls the Proc when authenticating to obtain the request token' do
+          it 'calls the lambda when authenticating to obtain the request token' do
             expect(@block_called).to eql(true)
             expect(@block_params).to include(token_params)
           end
@@ -517,7 +517,7 @@ describe Ably::Auth do
           let(:client_id)   { random_str }
 
           let!(:token_details) do
-            auth.request_token({}, auth_callback: Proc.new do |block_options|
+            auth.request_token({}, auth_callback: lambda do |token_params|
               auth.create_token_request(client_id: client_id)
             end)
           end
@@ -533,7 +533,7 @@ describe Ably::Auth do
           let(:token) { second_client.auth.request_token.token }
 
           let!(:token_details) do
-            auth.request_token({}, auth_callback: Proc.new do |block_options|
+            auth.request_token({}, auth_callback: lambda do |token_params|
               token
             end)
           end
@@ -689,7 +689,7 @@ describe Ably::Auth do
 
       context 'AuthOptions argument' do
         let(:token_ttl) { 2 }
-        let(:auth_callback) { Proc.new do
+        let(:auth_callback) { lambda do |token_params|
           auth.create_token_request(ttl: token_ttl)
         end }
         let(:default_auth_options) { { auth_callback: auth_callback } }
@@ -717,7 +717,7 @@ describe Ably::Auth do
         end
 
         it 'updates Auth#options attribute with an immutable hash' do
-          auth.authorize(nil, auth_callback: Proc.new { '1231232.12321:12321312' })
+          auth.authorize(nil, auth_callback: lambda { |token_params| '1231232.12321:12321312' })
           expect { auth.options['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
         end
 
@@ -763,17 +763,17 @@ describe Ably::Auth do
         expect(auth.options[:authUrl]).to eql('http://foo.com')
       end
 
-      context 'with a Proc for the :auth_callback option' do
+      context 'with a lambda for the :auth_callback option' do
         let(:client_id) { random_str }
         let!(:token) do
-          auth.authorize({}, auth_callback: Proc.new do
+          auth.authorize({}, auth_callback: lambda do |token_params|
             @block_called ||= 0
             @block_called += 1
             auth.create_token_request(client_id: client_id)
           end)
         end
 
-        it 'calls the Proc' do
+        it 'calls the lambda' do
           expect(@block_called).to eql(1)
         end
 
@@ -782,7 +782,7 @@ describe Ably::Auth do
         end
 
         context 'for every subsequent #request_token' do
-          context 'without a :auth_callback Proc' do
+          context 'without a :auth_callback lambda' do
             it 'calls the originally provided block' do
               auth.request_token
               expect(@block_called).to eql(2)
@@ -790,8 +790,8 @@ describe Ably::Auth do
           end
 
           context 'with a provided block' do
-            it 'does not call the originally provided Proc and calls the new #request_token :auth_callback Proc' do
-              auth.request_token({}, auth_callback: Proc.new { @request_block_called = true; auth.create_token_request })
+            it 'does not call the originally provided lambda and calls the new #request_token :auth_callback lambda' do
+              auth.request_token({}, auth_callback: lambda { |token_params| @request_block_called = true; auth.create_token_request })
               expect(@block_called).to eql(1)
               expect(@request_block_called).to eql(true)
             end
@@ -800,7 +800,7 @@ describe Ably::Auth do
       end
 
       context 'with an explicit token string that expires' do
-        context 'and a Proc for the :auth_callback option to provide a means to renew the token' do
+        context 'and a lambda for the :auth_callback option to provide a means to renew the token' do
           before do
             # Ensure a soon to expire token is not treated as expired
             stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0
@@ -811,13 +811,13 @@ describe Ably::Auth do
 
           let(:token_client)   { Ably::Rest::Client.new(default_options.merge(key: api_key, default_token_params: { ttl: 3 })) }
           let(:client_options) {
-            default_options.merge(token: token_client.auth.request_token.token, auth_callback: Proc.new do
+            default_options.merge(token: token_client.auth.request_token.token, auth_callback: lambda do |token_params|
               @block_called += 1
               token_client.auth.create_token_request
             end)
           }
 
-          it 'calls the Proc once the token has expired and the new token is used' do
+          it 'calls the lambda once the token has expired and the new token is used' do
             client.stats
             expect(@block_called).to eql(0)
             sleep 3.5
@@ -829,7 +829,7 @@ describe Ably::Auth do
 
       context 'with an explicit ClientOptions client_id' do
         let(:client_id)       { random_str }
-        let(:client_options)  { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id) }
+        let(:client_options)  { default_options.merge(auth_callback: lambda { |token_params| auth_token_object }, client_id: client_id) }
         let(:auth_client)     { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: 'invalid')) }
 
         context 'and an incompatible client_id in a TokenDetails object passed to the auth callback' do
@@ -871,7 +871,7 @@ describe Ably::Auth do
       end
 
       it 'returns a TokenRequest that can be passed to a client that can use it for authentication without an API key' do
-        auth_callback = Proc.new { subject }
+        auth_callback = proc { |token_params| subject }
         client_without_api_key = Ably::Rest::Client.new(default_options.merge(auth_callback: auth_callback))
         expect(client_without_api_key.auth).to be_using_token_auth
         expect { client_without_api_key.auth.authorize }.to_not raise_error
@@ -932,7 +932,7 @@ describe Ably::Auth do
         end
 
         it 'uses these capabilities when Ably issues an actual token' do
-          auth_callback = Proc.new { subject }
+          auth_callback = lambda { |token_params| subject }
           client_without_api_key = Ably::Rest::Client.new(default_options.merge(auth_callback: auth_callback))
           client_without_api_key.auth.authorize
           expect(client_without_api_key.auth.current_token_details.capability).to eql(capability)
@@ -1041,7 +1041,7 @@ describe Ably::Auth do
           end
 
           it 'is valid when used for authentication' do
-            auth_callback = Proc.new do
+            auth_callback = lambda do |callback|
               auth.create_token_request(token_attributes)
             end
             client = Ably::Rest::Client.new(auth_callback: auth_callback, environment: environment, protocol: protocol)
@@ -1324,36 +1324,9 @@ describe Ably::Auth do
       end
     end
 
-    context 'deprecated #authorise' do
+    context 'deprecated #authorise', :prevent_log_stubbing do
       let(:client_options)  { default_options.merge(key: api_key, logger: custom_logger_object, use_token_auth: true) }
-      let(:custom_logger) do
-        Class.new do
-          def initialize
-            @messages = []
-          end
-
-          [:fatal, :error, :warn, :info, :debug].each do |severity|
-            define_method severity do |message, &block|
-              message_val = [message]
-              message_val << block.call if block
-
-              @messages << [severity, message_val.compact.join(' ')]
-            end
-          end
-
-          def logs
-            @messages
-          end
-
-          def level
-            1
-          end
-
-          def level=(new_level)
-          end
-        end
-      end
-      let(:custom_logger_object) { custom_logger.new }
+      let(:custom_logger_object) { TestLogger.new }
 
       it 'logs a deprecation warning (#RSA10l)' do
         client.auth.authorise