ably-rest 0.8.5 → 0.8.6

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

@@ -132,7 +132,6 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       let(:client_options)  { default_options.merge(client_id: client_id) }
 
       it 'contains a #client_id attribute' do
-        skip 'Waiting for issue #256 to be resolved'
         when_all(channel.attach, other_client_channel.attach) do
           other_client_channel.subscribe('event') do |message|
             expect(message.client_id).to eql(client_id)
@@ -208,14 +207,26 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           end
         end
 
-        it 'will not echo messages to the client from other REST clients publishing using that connection_ID', em_timeout: 10 do
-          skip 'Waiting on realtime#285 to be resolved'
+        it 'will not echo messages to the client from other REST clients publishing using that connection_key', em_timeout: 10 do
           no_echo_channel.attach do
             no_echo_channel.subscribe('test_event') do |message|
               fail "Message should not have been echoed back"
             end
 
-            rest_client.channel(channel_name).publish('test_event', nil, connection_id: no_echo_client.connection.id)
+            rest_client.channel(channel_name).publish('test_event', nil, connection_key: no_echo_client.connection.key)
+            EventMachine.add_timer(1.5) do
+              stop_reactor
+            end
+          end
+        end
+
+        it 'will echo messages with a valid connection_id to the client from other REST clients publishing using that connection_key', em_timeout: 10 do
+          channel.attach do
+            channel.subscribe('test_event') do |message|
+              expect(message.connection_id).to eql(client.connection.id)
+            end
+
+            rest_client.channel(channel_name).publish('test_event', nil, connection_key: client.connection.key)
             EventMachine.add_timer(1.5) do
               stop_reactor
             end
@@ -599,7 +610,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       let(:event_name)     { random_str }
       let(:message_state)  { [] }
       let(:connection)     { client.connection }
-      let(:client_options) { default_options.merge(:log_level => :none) }
+      let(:client_options) { default_options.merge(:log_level => :fatal) }
       let(:msgs_received)  { [] }
 
       it 'publishes the message again, later receives the ACK and only one message is ever received from Ably' do
@@ -642,6 +653,32 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       let(:connection) { client.connection }
       let(:event_name) { random_str }
 
+      describe 'the connection is not resumed' do
+        let(:client_options) { default_options.merge(:log_level => :fatal) }
+
+        it 'calls the errback for all messages' do
+          connection.once(:connected) do
+            connection.transport.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+              if protocol_message.messages.find { |message| message.name == event_name }
+                EventMachine.add_timer(0.0001) do
+                  connection.transport.unbind # trigger failure
+                  connection.configure_new '0123456789abcdef', 'wVIsgTHAB1UvXh7z-1991d8586', -1 # force the resume connection key to be invalid
+                end
+              end
+            end
+          end
+
+          channel.publish(event_name).tap do |deferrable|
+            deferrable.callback do
+              raise 'Message delivery should not happen'
+            end
+            deferrable.errback do
+              stop_reactor
+            end
+          end
+        end
+      end
+
       describe 'the connection becomes suspended' do
         let(:client_options) { default_options.merge(:log_level => :fatal) }
 
@@ -649,8 +686,10 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           connection.once(:connected) do
             connection.transport.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.messages.find { |message| message.name == event_name }
-                EventMachine.add_timer(0.001) do
+                EventMachine.add_timer(0.0001) do
                   connection.transition_state_machine :suspended
+                  stub_const 'Ably::FALLBACK_HOSTS', []
+                  allow(client).to receive(:endpoint).and_return(URI::Generic.build(scheme: 'wss', host: 'does.not.exist.com'))
                 end
               end
             end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/presence_history_spec.rb

@@ -71,6 +71,10 @@ 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(: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
           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

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

@@ -9,9 +9,12 @@ describe Ably::Realtime::Presence, :event_machine do
     let(:client_options)  { default_options }
 
     let(:anonymous_client) { auto_close Ably::Realtime::Client.new(client_options) }
-    let(:client_one)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: random_str)) }
-    let(:client_two)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: random_str)) }
+    let(:client_one_id)    { random_str }
+    let(:client_one)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: client_one_id)) }
+    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(:channel_name)              { "presence-#{random_str(4)}" }
     let(:channel_anonymous_client)  { anonymous_client.channel(channel_name) }
     let(:presence_anonymous_client) { channel_anonymous_client.presence }
@@ -29,6 +32,14 @@ describe Ably::Realtime::Presence, :event_machine do
     end
 
     shared_examples_for 'a public presence method' do |method_name, expected_state, args, options = {}|
+      let(:client_id) do
+        if args.empty?
+          random_str
+        else
+          args
+        end
+      end
+
       def setup_test(method_name, args, options)
         if options[:enter_first]
           presence_client_one.public_send(method_name.to_s.gsub(/leave|update/, 'enter'), args) do
@@ -72,7 +83,7 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         context 'when :queue_messages client option is false' do
-          let(:client_one) { auto_close Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str)) }
+          let(:client_one) { auto_close Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: client_id)) }
 
           context 'and connection state initialized' do
             it 'raises an exception' do
@@ -94,7 +105,7 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           context 'and connection state disconnected' do
-            let(:client_one) { auto_close Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str, :log_level => :error)) }
+            let(:client_one) { auto_close Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: client_id, :log_level => :error)) }
 
             it 'raises an exception' do
               client_one.connection.once(:connected) do
@@ -122,7 +133,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with supported data payload content type' do
         def register_presence_and_check_data(method_name, data)
           if method_name.to_s.match(/_client/)
-            presence_client_one.public_send(method_name, 'client_id', data: data)
+            presence_client_one.public_send(method_name, client_id, data: data)
           else
             presence_client_one.public_send(method_name, data: data)
           end
@@ -177,7 +188,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with unsupported data payload content type' do
         def presence_action(method_name, data)
           if method_name.to_s.match(/_client/)
-            presence_client_one.public_send(method_name, 'client_id', data: data)
+            presence_client_one.public_send(method_name, client_id, data: data)
           else
             presence_client_one.public_send(method_name, data: data)
           end
@@ -255,15 +266,6 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       context 'if connection fails before success' do
-        before do
-          # Reconfigure client library so that it makes no retry attempts and fails immediately
-          stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
-                      Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
-                        disconnected: { retry_every: 0.1, max_time_in_state: 0 },
-                        suspended:    { retry_every: 0.1, max_time_in_state: 0 }
-                      )
-        end
-
         let(:client_options) { default_options.merge(log_level: :none) }
 
         it 'calls the Deferrable errback if channel is detached' do
@@ -272,7 +274,8 @@ describe Ably::Realtime::Presence, :event_machine do
               client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
                 # Don't allow any messages to reach the server
                 client_one.connection.__outgoing_protocol_msgbus__.unsubscribe
-                force_connection_failure client_one
+                error_message = Ably::Models::ProtocolMessage.new(action: 9, error: { message: 'force failure' })
+                client_one.connection.__incoming_protocol_msgbus__.publish :protocol_message, error_message
               end
 
               presence_client_one.public_send(method_name, args).tap do |deferrable|
@@ -288,6 +291,123 @@ describe Ably::Realtime::Presence, :event_machine do
       end
     end
 
+    shared_examples_for 'a presence on behalf of another client method' do |method_name|
+      context ":#{method_name} when authenticated with a wildcard client_id" do
+        let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*').token }
+        let(:client_options)   { default_options.merge(key: nil, token: token) }
+        let(:client)           { auto_close Ably::Realtime::Client.new(client_options) }
+        let(:presence_channel) { client.channels.get(channel_name).presence }
+
+        context 'and a valid client_id' do
+          it 'succeeds' do
+            presence_channel.public_send(method_name, 'clientId') do
+              EM.add_timer(0.5) { stop_reactor }
+            end.tap do |deferrable|
+              deferrable.errback { raise 'Should have succeeded' }
+            end
+          end
+        end
+
+        context 'and a wildcard client_id' do
+          it 'throws an exception' do
+            expect { presence_channel.public_send(method_name, '*') }.to raise_error Ably::Exceptions::IncompatibleClientId
+            stop_reactor
+          end
+        end
+
+        context 'and an empty client_id' do
+          it 'throws an exception' do
+            expect { presence_channel.public_send(method_name, nil) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            stop_reactor
+          end
+        end
+      end
+
+      context ":#{method_name} when authenticated with a valid client_id" do
+        let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: 'valid').token }
+        let(:client_options)   { default_options.merge(key: nil, token: token) }
+        let(:client)           { auto_close Ably::Realtime::Client.new(client_options.merge(log_level: :error)) }
+        let(:channel)          { client.channels.get(channel_name) }
+        let(:presence_channel) { channel.presence }
+
+        context 'and another invalid client_id' do
+          context 'before authentication' do
+            it 'allows the operation and then Ably rejects the operation' do
+              presence_channel.public_send(method_name, 'invalid').errback do |error|
+                expect(error.code).to eql(40012)
+                stop_reactor
+              end
+            end
+          end
+
+          context 'after authentication' do
+            it 'throws an exception' do
+              channel.attach do
+                expect { presence_channel.public_send(method_name, 'invalid') }.to raise_error Ably::Exceptions::IncompatibleClientId
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'and a wildcard client_id' do
+          it 'throws an exception' do
+            expect { presence_channel.public_send(method_name, '*') }.to raise_error Ably::Exceptions::IncompatibleClientId
+            stop_reactor
+          end
+        end
+
+        context 'and an empty client_id' do
+          it 'throws an exception' do
+            expect { presence_channel.public_send(method_name, nil) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            stop_reactor
+          end
+        end
+      end
+
+      context ":#{method_name} when anonymous and no client_id" do
+        let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: nil).token }
+        let(:client_options)   { default_options.merge(key: nil, token: token) }
+        let(:client)           { auto_close Ably::Realtime::Client.new(client_options.merge(log_level: :error)) }
+        let(:channel)          { client.channels.get(channel_name) }
+        let(:presence_channel) { channel.presence }
+
+        context 'and another invalid client_id' do
+          context 'before authentication' do
+            it 'allows the operation and then Ably rejects the operation' do
+              presence_channel.public_send(method_name, 'invalid').errback do |error|
+                expect(error.code).to eql(40012)
+                stop_reactor
+              end
+            end
+          end
+
+          context 'after authentication' do
+            it 'throws an exception' do
+              channel.attach do
+                expect { presence_channel.public_send(method_name, 'invalid') }.to raise_error Ably::Exceptions::IncompatibleClientId
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'and a wildcard client_id' do
+          it 'throws an exception' do
+            expect { presence_channel.public_send(method_name, '*') }.to raise_error Ably::Exceptions::IncompatibleClientId
+            stop_reactor
+          end
+        end
+
+        context 'and an empty client_id' do
+          it 'throws an exception' do
+            expect { presence_channel.public_send(method_name, nil) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            stop_reactor
+          end
+        end
+      end
+    end
+
     context 'when attached (but not present) on a presence channel with an anonymous client (no client ID)' do
       it 'maintains state as other clients enter and leave the channel' do
         channel_anonymous_client.attach do
@@ -394,6 +514,7 @@ describe Ably::Realtime::Presence, :event_machine do
         let(:present) { [] }
         let(:entered) { [] }
         let(:sync_pages_received) { [] }
+        let(:client_one) { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: wildcard_token)) }
 
         def setup_members_on(presence)
           enter_expected_count.times do |index|
@@ -434,7 +555,10 @@ describe Ably::Realtime::Presence, :event_machine do
                 presence_anonymous_client.subscribe(:leave) do |leave_message|
                   expect(leave_message.client_id).to eql(leave_member.client_id)
                   expect(present.count).to be < enter_expected_count
-                  stop_reactor
+                  EventMachine.add_timer(1) do
+                    presence_anonymous_client.unsubscribe
+                    stop_reactor
+                  end
                 end
 
                 anonymous_client.connect do
@@ -471,7 +595,10 @@ describe Ably::Realtime::Presence, :event_machine do
                   if present.count == enter_expected_count
                     presence_anonymous_client.get do |members|
                       expect(members.find { |member| member.client_id == leave_member.client_id}.action).to eq(:present)
-                      stop_reactor
+                      EventMachine.add_timer(1) do
+                        presence_anonymous_client.unsubscribe
+                        stop_reactor
+                      end
                     end
                   end
                 end
@@ -523,7 +650,10 @@ describe Ably::Realtime::Presence, :event_machine do
                   expect(members.count).to eql(enter_expected_count - 1)
                   expect(member_left_emitted).to eql(true)
                   expect(members.map(&:client_id)).to_not include(left_client_id)
-                  stop_reactor
+                  EventMachine.add_timer(1) do
+                    presence_anonymous_client.unsubscribe
+                    stop_reactor
+                  end
                 end
 
                 channel_anonymous_client.attach do
@@ -544,7 +674,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
           context '#get' do
             context 'with :wait_for_sync option set to true' do
-              it 'waits until sync is complete', event_machine: 15 do
+              it 'waits until sync is complete', em_timeout: 15 do
                 enter_expected_count.times do |index|
                   presence_client_one.enter_client("client:#{index}") do |message|
                     entered << message
@@ -561,7 +691,7 @@ describe Ably::Realtime::Presence, :event_machine do
             end
 
             context 'by default' do
-              it 'it does not wait for sync', event_machine: 15 do
+              it 'it does not wait for sync', em_timeout: 15 do
                 enter_expected_count.times do |index|
                   presence_client_one.enter_client("client:#{index}") do |message|
                     entered << message
@@ -656,7 +786,7 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'raises an exception if client_id is not set' do
-        expect { channel_anonymous_client.presence.enter }.to raise_error(Ably::Exceptions::Standard, /without a client_id/)
+        expect { channel_anonymous_client.presence.enter }.to raise_error(Ably::Exceptions::IncompatibleClientId, /without a client_id/)
         stop_reactor
       end
 
@@ -789,7 +919,7 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'raises an exception if not entered' do
-        expect { channel_anonymous_client.presence.leave }.to raise_error(Ably::Exceptions::Standard, /Unable to leave presence channel that is not entered/)
+        expect { channel_client_one.presence.leave }.to raise_error(Ably::Exceptions::Standard, /Unable to leave presence channel that is not entered/)
         stop_reactor
       end
 
@@ -824,8 +954,10 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context 'entering/updating/leaving presence state on behalf of another client_id' do
       let(:client_count) { 5 }
-      let(:clients) { [] }
-      let(:data) { random_str }
+      let(:clients)      { [] }
+      let(:data)         { random_str }
+      let(:client_one)   { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: wildcard_token)) }
+      let(:client_two)   { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: wildcard_token)) }
 
       context '#enter_client' do
         context 'multiple times on the same channel with different client_ids' do
@@ -875,8 +1007,6 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
 
-        it_should_behave_like 'a public presence method', :enter_client, nil, 'client_id'
-
         context 'without necessary capabilities to enter on behalf of another client' do
           let(:restricted_client) do
             auto_close Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
@@ -891,6 +1021,9 @@ describe Ably::Realtime::Presence, :event_machine do
             end
           end
         end
+
+        it_should_behave_like 'a public presence method', :enter_client, nil, 'client_id'
+        it_should_behave_like 'a presence on behalf of another client method', :enter_client
       end
 
       context '#update_client' do
@@ -955,6 +1088,7 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         it_should_behave_like 'a public presence method', :update_client, nil, 'client_id'
+        it_should_behave_like 'a presence on behalf of another client method', :update_client
       end
 
       context '#leave_client' do
@@ -1048,6 +1182,7 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         it_should_behave_like 'a public presence method', :leave_client, nil, 'client_id'
+        it_should_behave_like 'a presence on behalf of another client method', :leave_client
       end
     end
 
@@ -1091,10 +1226,11 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       context 'during a sync' do
-        let(:pages) { 2 }
-        let(:members_per_page) { 100 }
+        let(:pages)               { 2 }
+        let(:members_per_page)    { 100 }
         let(:sync_pages_received) { [] }
-        let(:client_options) { default_options.merge(log_level: :none) }
+        let(:client_one)          { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: wildcard_token)) }
+        let(:client_options)      { default_options.merge(log_level: :none) }
 
         def connect_members_deferrables
           (members_per_page * pages + 1).times.map do |index|
@@ -1102,15 +1238,6 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
 
-        before do
-          # Reconfigure client library so that it makes no retry attempts and fails immediately
-          stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
-                      Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
-                        disconnected: { retry_every: 0.1, max_time_in_state: 0 },
-                        suspended:    { retry_every: 0.1, max_time_in_state: 0 }
-                      )
-        end
-
         context 'when :wait_for_sync is true' do
           it 'fails if the connection fails' do
             when_all(*connect_members_deferrables) do
@@ -1118,7 +1245,10 @@ describe Ably::Realtime::Presence, :event_machine do
                 client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
                   if protocol_message.action == :sync
                     sync_pages_received << protocol_message
-                    force_connection_failure client_two if sync_pages_received.count == 1
+                    if sync_pages_received.count == 1
+                      error_message = Ably::Models::ProtocolMessage.new(action: 9, error: { message: 'force failure' })
+                      client_two.connection.__incoming_protocol_msgbus__.publish :protocol_message, error_message
+                    end
                   end
                 end
               end
@@ -1196,22 +1326,22 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'filters by client_id option if provided' do
-        presence_client_one.enter(client_id: 'one') do
-          presence_client_two.enter client_id: 'two'
+        presence_client_one.enter do
+          presence_client_two.enter
         end
 
         presence_client_one.subscribe(:enter) do |presence_message|
           # wait until the client_two enter event has been sent to client_one
-          next unless presence_message.client_id == 'two'
+          next unless presence_message.client_id == client_two_id
 
-          presence_client_one.get(client_id: 'one') do |members|
+          presence_client_one.get(client_id: client_one_id) do |members|
             expect(members.count).to eq(1)
-            expect(members.first.client_id).to eql('one')
+            expect(members.first.client_id).to eql(client_one_id)
             expect(members.first.connection_id).to eql(client_one.connection.id)
 
-            presence_client_one.get(client_id: 'two') do |members|
+            presence_client_one.get(client_id: client_two_id) do |members|
               expect(members.count).to eq(1)
-              expect(members.first.client_id).to eql('two')
+              expect(members.first.client_id).to eql(client_two_id)
               expect(members.first.connection_id).to eql(client_two.connection.id)
               stop_reactor
             end
@@ -1220,7 +1350,7 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'does not wait for SYNC to complete if :wait_for_sync option is false' do
-        presence_client_one.enter(client_id: 'one') do
+        presence_client_one.enter do
           presence_client_two.get(wait_for_sync: false) do |members|
             expect(members.count).to eql(0)
             stop_reactor
@@ -1242,6 +1372,8 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       context 'with lots of members on different clients' do
+        let(:client_one)         { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: wildcard_token)) }
+        let(:client_two)         { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: wildcard_token)) }
         let(:members_per_client) { 10 }
         let(:clients_entered)    { Hash.new { |hash, key| hash[key] = 0 } }
         let(:total_members)      { members_per_client * 2 }
@@ -1588,7 +1720,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       it 'resumes the SYNC operation', em_timeout: 15 do
         when_all(*members_count.times.map do |index|
-          presence_client_one.enter_client("client:#{index}")
+          presence_anonymous_client.enter_client("client:#{index}")
         end) do
           channel_client_two.attach do
             client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|