ably-rest 0.8.2 → 0.8.3

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

@@ -167,12 +167,12 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
         context 'when connection state is :failed' do
           describe '#close' do
-            it 'will not transition state to :close and raises a StateChangeError exception' do
+            it 'will not transition state to :close and raises a InvalidStateChange exception' do
               connection.on(:connected) { raise 'Connection should not have reached :connected state' }
 
               connection.once(:failed) do
                 expect(connection.state).to eq(:failed)
-                expect { connection.close }.to raise_error Ably::Exceptions::StateChangeError, /Unable to transition from failed => closing/
+                expect { connection.close }.to raise_error Ably::Exceptions::InvalidStateChange, /Unable to transition from failed => closing/
                 stop_reactor
               end
             end
@@ -228,6 +228,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
 
         context 'connection opening times out' do
+          let(:client_options) { client_failure_options }
+
           it 'attempts to reconnect' do
             started_at = Time.now
 
@@ -249,8 +251,6 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
 
           context 'when retry intervals are stubbed to attempt reconnection quickly' do
-            let(:client_options) { client_failure_options }
-
             before do
               # Reconfigure client library retry periods and timeouts so that tests run quickly
               stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
@@ -488,7 +488,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             when_all(*channels.map(&:attach)) do
               detached_channels = []
               channels.each do |channel|
-                channel.on(:detached) do
+                channel.on(:detached) do |error|
+                  expect(error.message).to match(/Invalid connection key/i)
                   detached_channels << channel
                   next unless detached_channels.count == channel_count
                   expect(detached_channels.count).to eql(channel_count)
@@ -537,7 +538,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
       context 'with custom realtime websocket host option' do
         let(:expected_host) { 'this.host.does.not.exist' }
-        let(:client_options) { default_options.merge(realtime_host: expected_host, log_level: :none) }
+        let(:client_options) { default_options.merge(realtime_host: expected_host, :environment => :production, log_level: :none) }
 
         it 'never uses a fallback host' do
           expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host|
@@ -551,6 +552,22 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
       end
 
+      context 'with custom realtime websocket port option' do
+        let(:custom_port) { 666}
+        let(:client_options) { default_options.merge(tls_port: custom_port, :environment => :production, log_level: :none) }
+
+        it 'never uses a fallback host' do
+          expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host, port|
+            expect(port).to eql(custom_port)
+            raise EventMachine::ConnectionError
+          end
+
+          connection.on(:failed) do
+            stop_reactor
+          end
+        end
+      end
+
       context 'with non-production environment' do
         let(:environment)    { 'sandbox' }
         let(:expected_host)  { "#{environment}-#{Ably::Realtime::Client::DOMAIN}" }

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

@@ -52,9 +52,12 @@ describe Ably::Realtime::Connection, :event_machine do
         before do
           # Reduce token expiry buffer to zero so that a token expired? predicate is exact
           # Normally there is a buffer so that a token expiring soon is considered expired
+          @original_token_expiry_buffer = Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER
           stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0
         end
 
+        let(:original_token_expiry_buffer) { @original_token_expiry_buffer }
+
         context 'for renewable tokens' do
           context 'that are valid for the duration of the test' do
             context 'with valid pre authorised token expiring in the future' do
@@ -71,7 +74,7 @@ describe Ably::Realtime::Connection, :event_machine do
               let(:client_options) { default_options.merge(client_id: 'force_token_auth') }
 
               it 'uses the token created by the implicit authorisation' do
-                expect(client.auth).to receive(:request_token).once.and_call_original
+                expect(client.rest_client.auth).to receive(:request_token).once.and_call_original
 
                 connection.once(:connected) do
                   stop_reactor
@@ -84,20 +87,36 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(log_level: :none) }
 
             before do
-              client.auth.authorise(ttl: ttl)
+              expect(client.rest_client.time.to_f).to be_within(2).of(Time.now.to_i), "Local clock is out of sync with Ably"
+            end
+
+            before do
+              # Ensure tokens issued expire immediately after issue
+              @original_renew_token_buffer = Ably::Auth::TOKEN_DEFAULTS.fetch(:renew_token_buffer)
+              stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0)
+
+              # Authorise synchronously to ensure token has been issued
+              client.auth.authorise_sync(token_params: { ttl: ttl })
             end
 
+            let(:original_renew_token_buffer) { @original_renew_token_buffer }
+
             context 'opening a new connection' do
               context 'with recently expired token' do
                 let(:ttl) { 2 }
 
-                it 'renews the token on connect' do
-                  sleep ttl + 0.1
-                  expect(client.auth.current_token_details).to be_expired
-                  expect(client.auth).to receive(:authorise).at_least(:once).and_call_original
-                  connection.once(:connected) do
-                    expect(client.auth.current_token_details).to_not be_expired
-                    stop_reactor
+                it 'renews the token on connect without changing connection state' do
+                  connection.once(:connecting) do
+                    sleep ttl + 0.1
+                    expect(client.auth.current_token_details).to be_expired
+                    expect(client.rest_client.auth).to receive(:authorise).at_least(:once).and_call_original
+                    connection.once(:connected) do
+                      expect(client.auth.current_token_details).to_not be_expired
+                      stop_reactor
+                    end
+                    connection.once_state_changed do
+                      raise "Invalid state #{connection.state}" unless connection.state == :connected
+                    end
                   end
                 end
               end
@@ -106,7 +125,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 let(:ttl) { 0.001 }
 
                 it 'renews the token on connect, and only makes one subsequent attempt to obtain a new token' do
-                  expect(client.auth).to receive(:authorise).at_least(:twice).and_call_original
+                  expect(client.rest_client.auth).to receive(:authorise).at_least(:twice).and_call_original
                   connection.once(:disconnected) do
                     connection.once(:failed) do |error|
                       expect(error.code).to eql(40140) # token expired
@@ -149,6 +168,12 @@ describe Ably::Realtime::Connection, :event_machine do
                     connection.once(:connected) do
                       started_at = Time.now
                       connection.once(:disconnected) do |error|
+                        expect(error.code).to eq(40140) # Token expired
+
+                        # Token has expired, so now ensure it is not used again
+                        stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', original_token_expiry_buffer
+                        stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: original_renew_token_buffer)
+
                         connection.once(:connected) do
                           expect(client.auth.current_token_details).to_not be_expired
                           expect(Time.now - started_at >= ttl)
@@ -159,6 +184,8 @@ describe Ably::Realtime::Connection, :event_machine do
                       end
                     end
 
+                    connection.unsafe_once(:failed) { |error| fail error.inspect }
+
                     channel.attach
                   end
                 end
@@ -172,8 +199,13 @@ describe Ably::Realtime::Connection, :event_machine do
 
         context 'for non-renewable tokens' do
           context 'that are expired' do
+            before do
+              stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0)
+            end
+
             let!(:expired_token_details) do
-              Ably::Realtime::Client.new(default_options).auth.request_token(ttl: 0.01)
+              # Request a token synchronously
+              Ably::Realtime::Client.new(default_options).auth.request_token_sync(token_params: { ttl: 0.01 })
             end
 
             context 'opening a new connection' do
@@ -260,6 +292,20 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
 
+      describe 'connection#id' do
+        it 'is null before connecting' do
+          expect(connection.id).to be_nil
+          stop_reactor
+        end
+      end
+
+      describe 'connection#key' do
+        it 'is null before connecting' do
+          expect(connection.key).to be_nil
+          stop_reactor
+        end
+      end
+
       describe 'once connected' do
         let(:connection2) {  Ably::Realtime::Client.new(client_options).connection }
 
@@ -326,6 +372,18 @@ describe Ably::Realtime::Connection, :event_machine do
           end
         end
       end
+
+      context 'when closing' do
+        it 'raises an exception before the connection is closed' do
+          connection.connect do
+            connection.once(:closing) do
+              expect { connection.connect }.to raise_error Ably::Exceptions::InvalidStateChange
+              stop_reactor
+            end
+            connection.close
+          end
+        end
+      end
     end
 
     describe '#serial connection serial' do
@@ -339,7 +397,6 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       context 'when a message is sent but the ACK has not yet been received' do
-
         it 'the sent message msgSerial is 0 but the connection serial remains at -1' do
           channel.attach do
             connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
@@ -732,13 +789,13 @@ describe Ably::Realtime::Connection, :event_machine do
     context 'when a state transition is unsupported' do
       let(:client_options) { default_options.merge(log_level: :none) } # silence FATAL errors
 
-      it 'emits a StateChangeError' do
+      it 'emits a InvalidStateChange' do
         connection.connect do
           connection.transition_state_machine :initialized
         end
 
         connection.on(:error) do |error|
-          expect(error).to be_a(Ably::Exceptions::StateChangeError)
+          expect(error).to be_a(Ably::Exceptions::InvalidStateChange)
           stop_reactor
         end
       end
@@ -794,16 +851,41 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         context 'when the Internet is up' do
+          let(:client_options) { default_options.merge(tls: false, use_token_auth: true) }
+
+          context 'with a TLS connection' do
+            let(:client_options) { default_options.merge(tls: true) }
+
+            it 'checks the Internet up URL over TLS' do
+              expect(EventMachine::HttpRequest).to receive(:new).with("https:#{Ably::INTERNET_CHECK.fetch(:url)}").and_return(double('request', get: EventMachine::DefaultDeferrable.new))
+              connection.internet_up?
+              stop_reactor
+            end
+          end
+
+          context 'with a non-TLS connection' do
+            let(:client_options) { default_options.merge(tls: false, use_token_auth: true) }
+
+            it 'checks the Internet up URL over TLS' do
+              expect(EventMachine::HttpRequest).to receive(:new).with("http:#{Ably::INTERNET_CHECK.fetch(:url)}").and_return(double('request', get: EventMachine::DefaultDeferrable.new))
+              connection.internet_up?
+              stop_reactor
+            end
+          end
+
           it 'calls the block with true' do
             connection.internet_up? do |result|
               expect(result).to be_truthy
-              stop_reactor
+              EventMachine.add_timer(0.2) { stop_reactor }
             end
           end
 
           it 'calls the success callback of the Deferrable' do
             connection.internet_up?.callback do
-              stop_reactor
+              EventMachine.add_timer(0.2) { stop_reactor }
+            end
+            connection.internet_up?.errback do |error|
+              raise "Could not perform the Internet up check. Are you connected to the Internet? #{error}"
             end
           end
         end
@@ -828,5 +910,74 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+    describe 'state change side effects' do
+      let(:channel)        { client.channels.get(random_str) }
+      let(:client_options) { default_options.merge(:log_level => :error) }
+
+      context 'when connection enters the :disconnected state' do
+        it 'queues messages to be sent and all channels remain attached' do
+          channel.attach do
+            connection.once(:disconnected) do
+              expect(connection.__outgoing_message_queue__).to be_empty
+              channel.publish 'test'
+
+              EventMachine.add_timer(0.02) do
+                expect(connection.__outgoing_message_queue__).to_not be_empty
+              end
+
+              connection.once(:connected) do
+                EventMachine.add_timer(0.02) do
+                  expect(connection.__outgoing_message_queue__).to be_empty
+                  stop_reactor
+                end
+              end
+            end
+
+            connection.transport.close_connection_after_writing
+          end
+        end
+      end
+
+      context 'when connection enters the :suspended state' do
+        before do
+          # Reconfigure client library retry periods so that client stays in suspended state
+          stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
+                      Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
+                        disconnected: { retry_every: 0.01, max_time_in_state: 0.05 },
+                        suspended: { retry_every: 60, max_time_in_state: 60 }
+                      )
+        end
+
+        it 'detaches the channels and prevents publishing of messages on those channels' do
+          channel.attach do
+            channel.once(:detached) do
+              expect { channel.publish 'test' }.to raise_error(Ably::Exceptions::ChannelInactive)
+              stop_reactor
+            end
+
+            # Keep disconnecting the websocket transport after it attempts reconnection
+            connection.transport.close_connection_after_writing
+            connection.on(:connecting) do
+              EventMachine.add_timer(0.03) do
+                connection.transport.close_connection_after_writing
+              end
+            end
+          end
+        end
+      end
+
+      context 'when connection enters the :failed state' do
+        let(:client_options) { default_options.merge(:key => 'will.not:authenticate', log_level: :none) }
+
+        it 'sets all channels to failed and prevents publishing of messages on those channels' do
+          channel.attach
+          channel.once(:failed) do
+            expect { channel.publish 'test' }.to raise_error(Ably::Exceptions::ChannelInactive)
+            stop_reactor
+          end
+        end
+      end
+    end
   end
 end

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

@@ -79,8 +79,8 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Integer' do
         let(:data) { 1 }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
       end
@@ -88,8 +88,8 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Float' do
         let(:data) { 1.1 }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
       end
@@ -97,8 +97,8 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Boolean' do
         let(:data) { true }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
       end
@@ -106,8 +106,8 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'False' do
         let(:data) { false }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
       end
@@ -132,6 +132,7 @@ 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)

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

@@ -22,6 +22,7 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
       presence_client_one.enter(data: data) do
         presence_client_one.leave(data: leave_data) do
           presence_client_one.history do |history_page|
+            expect(history_page).to be_a(Ably::Models::PaginatedResult)
             expect(history_page.items.count).to eql(2)
 
             expect(history_page.items[1].action).to eq(:enter)

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

@@ -45,7 +45,62 @@ describe Ably::Realtime::Presence, :event_machine do
             setup_test(method_name, args, options) do
               channel_client_one.attach do
                 channel_client_one.change_state state.to_sym
-                expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::IncompatibleStateForOperation, /Operation is not allowed when channel is in STATE.#{state}/i
+                expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.#{state}/i
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        it 'implicitly attaches the channel' do
+          expect(channel_client_one).to_not be_attached
+          presence_client_one.public_send(method_name, args) do
+            expect(channel_client_one).to be_attached
+            stop_reactor
+          end
+        end
+
+        context 'when :queue_messages client option is false' do
+          let(:client_one) { Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str)) }
+
+          context 'and connection state initialized' do
+            it 'raises an exception' do
+              expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::MessageQueueingDisabled
+              expect(client_one.connection).to be_initialized
+              stop_reactor
+            end
+          end
+
+          context 'and connection state connecting' do
+            it 'raises an exception' do
+              client_one.connect
+              EventMachine.next_tick do
+                expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::MessageQueueingDisabled
+                expect(client_one.connection).to be_connecting
+                stop_reactor
+              end
+            end
+          end
+
+          context 'and connection state disconnected' do
+            let(:client_one) { Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str, :log_level => :error)) }
+
+            it 'raises an exception' do
+              client_one.connection.once(:connected) do
+                client_one.connection.once(:disconnected) do
+                  expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::MessageQueueingDisabled
+                  expect(client_one.connection).to be_disconnected
+                  stop_reactor
+                end
+                client_one.connection.transition_state_machine :disconnected
+              end
+            end
+          end
+
+          context 'and connection state connected' do
+            it 'publishes the message' do
+              client_one.connection.once(:connected) do
+                presence_client_one.public_send(method_name, args)
                 stop_reactor
               end
             end
@@ -120,8 +175,8 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Integer' do
           let(:data) { 1 }
 
-          it 'raises an UnsupportedDataTypeError 40011 exception' do
-            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          it 'raises an UnsupportedDataType 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
         end
@@ -129,8 +184,8 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Float' do
           let(:data) { 1.1 }
 
-          it 'raises an UnsupportedDataTypeError 40011 exception' do
-            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          it 'raises an UnsupportedDataType 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
         end
@@ -138,8 +193,8 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Boolean' do
           let(:data) { true }
 
-          it 'raises an UnsupportedDataTypeError 40011 exception' do
-            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          it 'raises an UnsupportedDataType 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
         end
@@ -147,8 +202,8 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'False' do
           let(:data) { false }
 
-          it 'raises an UnsupportedDataTypeError 40011 exception' do
-            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          it 'raises an UnsupportedDataType 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
         end
@@ -161,6 +216,14 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      it 'allows a block to be passed in that is executed upon success' do
+        setup_test(method_name, args, options) do
+          presence_client_one.public_send(method_name, args) do
+            stop_reactor
+          end
+        end
+      end
+
       it 'calls the Deferrable callback on success' do
         setup_test(method_name, args, options) do
           presence_client_one.public_send(method_name, args).callback do |presence|
@@ -1002,7 +1065,7 @@ describe Ably::Realtime::Presence, :event_machine do
         it "raise an exception if the channel is #{state}" do
           channel_client_one.attach do
             channel_client_one.change_state state.to_sym
-            expect { presence_client_one.get }.to raise_error Ably::Exceptions::IncompatibleStateForOperation, /Operation is not allowed when channel is in STATE.#{state}/i
+            expect { presence_client_one.get }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.#{state}/i
             stop_reactor
           end
         end
@@ -1218,6 +1281,36 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
       end
+
+      context 'with event name' do
+        it 'calls the callback for specified presence event' do
+          when_all(channel_client_one.attach, channel_client_two.attach) do
+            presence_client_two.subscribe(:leave) do |presence_message|
+              messages << presence_message
+              next unless messages.count == 1
+
+              expect(messages.map(&:action).map(&:to_sym)).to contain_exactly(:leave)
+              stop_reactor
+            end
+
+            presence_client_one.enter do
+              presence_client_one.update do
+                presence_client_one.leave
+              end
+            end
+          end
+        end
+      end
+
+      it 'implicitly attaches' do
+        expect(client_one.connection).to be_initialized
+        presence_client_one.subscribe { true }
+        channel_client_one.on(:attached) do
+          expect(client_one.connection).to be_connected
+          expect(channel_client_one).to be_attached
+          stop_reactor
+        end
+      end
     end
 
     context '#unsubscribe' do
@@ -1238,6 +1331,24 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
       end
+
+      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' }
+            presence_client_two.subscribe :leave, &subscribe_callback
+            presence_client_two.unsubscribe :leave, &subscribe_callback
+
+            presence_client_one.enter do
+              presence_client_one.leave do
+                EventMachine.add_timer(1) do
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
     end
 
     context 'REST #get' do