ably 0.8.3 → 0.8.4

data/spec/acceptance/realtime/client_spec.rb

@@ -31,8 +31,8 @@ describe Ably::Realtime::Client, :event_machine do
             it 'fails to connect because a private key cannot be sent over a non-secure connection' do
               connection.on(:connected) { raise 'Should not have connected' }
 
-              connection.on(:failed) do |error|
-                expect(error).to be_a(Ably::Exceptions::InsecureRequest)
+              connection.on(:failed) do |connection_state_change|
+                expect(connection_state_change.reason).to be_a(Ably::Exceptions::InsecureRequest)
                 stop_reactor
               end
             end

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -24,7 +24,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           let(:invalid_key) { 'not_an_app.invalid_key_name:invalid_key_value' }
 
           it 'enters the failed state and returns a not found error' do
-            connection.on(:failed) do |error|
+            connection.on(:failed) do |connection_state_change|
+              error = connection_state_change.reason
               expect(connection.state).to eq(:failed)
               # TODO: Check error type is an InvalidToken exception
               expect(error.status).to eq(404)
@@ -38,7 +39,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           let(:invalid_key) { "#{app_id}.invalid_key_name:invalid_key_value" }
 
           it 'enters the failed state and returns an authorization error' do
-            connection.on(:failed) do |error|
+            connection.on(:failed) do |connection_state_change|
+              error = connection_state_change.reason
               expect(connection.state).to eq(:failed)
               # TODO: Check error type is a TokenNotFOund exception
               expect(error.status).to eq(401)
@@ -182,7 +184,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         context '#error_reason' do
           [:disconnected, :suspended, :failed].each do |state|
             it "contains the error when state is #{state}" do
-              connection.on(state) do |error|
+              connection.on(state) do |connection_state_change|
+                error = connection_state_change.reason
                 expect(connection.error_reason).to eq(error)
                 expect(connection.error_reason.code).to eql(80000)
                 stop_reactor
@@ -488,7 +491,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 |error|
+                channel.on(:detached) do |channel_state_change|
+                  error = channel_state_change.reason
                   expect(error.message).to match(/Invalid connection key/i)
                   detached_channels << channel
                   next unless detached_channels.count == channel_count

data/spec/acceptance/realtime/connection_spec.rb

@@ -127,8 +127,8 @@ describe Ably::Realtime::Connection, :event_machine do
                 it 'renews the token on connect, and only makes one subsequent attempt to obtain a new token' do
                   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
+                    connection.once(:failed) do |connection_state_change|
+                      expect(connection_state_change.reason.code).to eql(40140) # token expired
                       stop_reactor
                     end
                   end
@@ -167,8 +167,8 @@ 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
+                      connection.once(:disconnected) do |connection_state_change|
+                        expect(connection_state_change.reason.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
@@ -178,7 +178,6 @@ describe Ably::Realtime::Connection, :event_machine do
                           expect(client.auth.current_token_details).to_not be_expired
                           expect(Time.now - started_at >= ttl)
                           expect(original_token).to be_expired
-                          expect(error.code).to eql(40140) # token expired
                           stop_reactor
                         end
                       end
@@ -922,12 +921,12 @@ describe Ably::Realtime::Connection, :event_machine do
               expect(connection.__outgoing_message_queue__).to be_empty
               channel.publish 'test'
 
-              EventMachine.add_timer(0.02) do
+              EventMachine.next_tick do
                 expect(connection.__outgoing_message_queue__).to_not be_empty
               end
 
               connection.once(:connected) do
-                EventMachine.add_timer(0.02) do
+                EventMachine.add_timer(0.1) do
                   expect(connection.__outgoing_message_queue__).to be_empty
                   stop_reactor
                 end
@@ -940,6 +939,8 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       context 'when connection enters the :suspended state' do
+        let(:client_options) { default_options.merge(:log_level => :fatal) }
+
         before do
           # Reconfigure client library retry periods so that client stays in suspended state
           stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
@@ -956,13 +957,21 @@ describe Ably::Realtime::Connection, :event_machine do
               stop_reactor
             end
 
+            close_connection_proc = Proc.new do
+              EventMachine.add_timer(0.001) do
+                if connection.transport.nil?
+                  close_connection_proc.call
+                else
+                  connection.transport.close_connection_after_writing
+                end
+              end
+            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
+              close_connection_proc.call
             end
+            close_connection_proc.call
           end
         end
       end
@@ -979,5 +988,107 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+    context 'connection state change' do
+      it 'emits a ConnectionStateChange object' do
+        connection.on(:connected) do |connection_state_change|
+          expect(connection_state_change).to be_a(Ably::Models::ConnectionStateChange)
+          stop_reactor
+        end
+      end
+
+      context 'ConnectionStateChange object' do
+        it 'has current state' do
+          connection.on(:connected) do |connection_state_change|
+            expect(connection_state_change.current).to eq(:connected)
+            stop_reactor
+          end
+        end
+
+        it 'has a previous state' do
+          connection.on(:connected) do |connection_state_change|
+            expect(connection_state_change.previous).to eq(:connecting)
+            stop_reactor
+          end
+        end
+
+        it 'contains a private API protocol_message attribute that is used for special state change events', :api_private do
+          connection.on(:connected) do |connection_state_change|
+            expect(connection_state_change.protocol_message).to be_a(Ably::Models::ProtocolMessage)
+            expect(connection_state_change.reason).to be_nil
+            stop_reactor
+          end
+        end
+
+        it 'has an empty reason when there is no error' do
+          connection.on(:closed) do |connection_state_change|
+            expect(connection_state_change.reason).to be_nil
+            stop_reactor
+          end
+          connection.connect do
+            connection.close
+          end
+        end
+
+        context 'on failure' do
+          let(:client_options) { default_options.merge(log_level: :none) }
+
+          it 'has a reason Error object when there is an error on the connection' do
+            connection.on(:failed) do |connection_state_change|
+              expect(connection_state_change.reason).to be_a(Ably::Exceptions::BaseAblyException)
+              stop_reactor
+            end
+            connection.connect do
+              error = Ably::Exceptions::ConnectionFailed.new('forced failure', 500, 50000)
+              client.connection.manager.error_received_from_server error
+            end
+          end
+        end
+
+        context 'retry_in' do
+          let(:client_options) { default_options.merge(log_level: :debug) }
+
+          it 'is nil when a retry is not required' do
+            connection.on(:connected) do |connection_state_change|
+              expect(connection_state_change.retry_in).to be_nil
+              stop_reactor
+            end
+          end
+
+          it 'is 0 when first attempt to connect fails' do
+            connection.once(:connecting) do
+              connection.once(:disconnected) do |connection_state_change|
+                expect(connection_state_change.retry_in).to eql(0)
+                stop_reactor
+              end
+              EventMachine.add_timer(0.001) { connection.transport.unbind }
+            end
+          end
+
+          it 'is 0 when an immediate reconnect will occur' do
+            connection.once(:connected) do
+              connection.once(:disconnected) do |connection_state_change|
+                expect(connection_state_change.retry_in).to eql(0)
+                stop_reactor
+              end
+              connection.transport.unbind
+            end
+          end
+
+          it 'contains the next retry period when an immediate reconnect will not occur' do
+            connection.once(:connected) do
+              connection.once(:connecting) do
+                connection.once(:disconnected) do |connection_state_change|
+                  expect(connection_state_change.retry_in).to be > 0
+                  stop_reactor
+                end
+                EventMachine.add_timer(0.001) { connection.transport.unbind }
+              end
+              connection.transport.unbind
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/acceptance/realtime/message_spec.rb

@@ -181,10 +181,14 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
       context 'with :echo_messages option set to false' do
         let(:no_echo_client) do
-          Ably::Realtime::Client.new(default_options.merge(echo_messages: false))
+          Ably::Realtime::Client.new(default_options.merge(echo_messages: false, log_level: :debug))
         end
         let(:no_echo_channel) { no_echo_client.channel(channel_name) }
 
+        let(:rest_client) do
+          Ably::Rest::Client.new(default_options.merge(log_level: :debug))
+        end
+
         it 'will not echo messages to the client but will still broadcast messages to other connected clients', em_timeout: 10 do
           channel.attach do |echo_channel|
             no_echo_channel.attach do
@@ -196,13 +200,27 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
               echo_channel.subscribe('test_event') do |message|
                 expect(message.data).to eql(payload)
-                EventMachine.add_timer(1) do
+                EventMachine.add_timer(1.5) do
                   stop_reactor
                 end
               end
             end
           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'
+          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)
+            EventMachine.add_timer(1.5) do
+              stop_reactor
+            end
+          end
+        end
       end
     end
 
@@ -257,7 +275,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(key: restricted_api_key, environment: environment, protocol: protocol))
+        Ably::Realtime::Client.new(options.merge(key: restricted_api_key, environment: environment, protocol: protocol, :log_level => :error))
       end
       let(:restricted_channel) { restricted_client.channel("cansubscribe:example") }
       let(:payload)            { 'Test message without permission to publish' }
@@ -569,5 +587,103 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         end
       end
     end
+
+    describe 'when message is published, the connection disconnects before the ACK is received, and the connection is resumed' do
+      let(:event_name)     { random_str }
+      let(:message_state)  { [] }
+      let(:connection)     { client.connection }
+      let(:client_options) { default_options.merge(:log_level => :debug) }
+      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
+          expect(message_state).to be_empty
+          EventMachine.add_timer(2) do
+            expect(message_state).to contain_exactly(:delivered)
+            # TODO: Uncomment once issue realtime#42 is resolved
+            # expect(msgs_received.length).to eql(1)
+            stop_reactor
+          end
+        end
+
+        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
+                connection.transport.unbind # trigger failure
+                expect(message_state).to be_empty
+                connection.once :connected, &on_reconnected
+              end
+            end
+          end
+        end
+
+        channel.publish(event_name).tap do |deferrable|
+          deferrable.callback { message_state << :delivered }
+          deferrable.errback do
+            raise 'Message delivery should not fail'
+          end
+        end
+
+        channel.subscribe do |message|
+          msgs_received << message
+        end
+      end
+    end
+
+    describe 'when message is published, the connection disconnects before the ACK is received' do
+      let(:connection) { client.connection }
+      let(:event_name) { random_str }
+
+      describe 'the connection becomes suspended' 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.001) do
+                  connection.transition_state_machine :suspended
+                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 failed' do
+        let(:client_options) { default_options.merge(:log_level => :none) }
+
+        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.001) do
+                  connection.transition_state_machine :failed, reason: RuntimeError.new
+                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
+    end
   end
 end

data/spec/acceptance/realtime/presence_spec.rb

@@ -40,18 +40,29 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       unless expected_state == :left
-        %w(detached failed).each do |state|
-          it "raise an exception if the channel is #{state}" 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::InvalidStateChange, /Operation is not allowed when channel is in STATE.#{state}/i
+        it 'raise an exception if the channel is detached' do
+          setup_test(method_name, args, options) do
+            channel_client_one.attach do
+              channel_client_one.transition_state_machine :detaching
+              channel_client_one.once(:detached) do
+                expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.detached/i
                 stop_reactor
               end
             end
           end
         end
 
+        it 'raise an exception if the channel is failed' do
+          setup_test(method_name, args, options) do
+            channel_client_one.attach do
+              channel_client_one.transition_state_machine :failed
+              expect(channel_client_one.state).to eq(:failed)
+              expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.failed/i
+              stop_reactor
+            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
@@ -1061,16 +1072,25 @@ describe Ably::Realtime::Presence, :event_machine do
         presence_client_one.get { raise 'Intentional exception' }
       end
 
-      %w(detached failed).each do |state|
-        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::InvalidStateChange, /Operation is not allowed when channel is in STATE.#{state}/i
+      it 'raise an exception if the channel is detached' do
+        channel_client_one.attach do
+          channel_client_one.transition_state_machine :detaching
+          channel_client_one.once(:detached) do
+            expect { presence_client_one.get }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.detached/i
             stop_reactor
           end
         end
       end
 
+      it 'raise an exception if the channel is failed' do
+        channel_client_one.attach do
+          channel_client_one.transition_state_machine :failed
+          expect(channel_client_one.state).to eq(:failed)
+          expect { presence_client_one.get }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.failed/i
+          stop_reactor
+        end
+      end
+
       context 'during a sync' do
         let(:pages) { 2 }
         let(:members_per_page) { 100 }
@@ -1120,8 +1140,8 @@ describe Ably::Realtime::Presence, :event_machine do
                   if protocol_message.action == :sync
                     # prevent any more SYNC messages coming through
                     client_two.connection.transport.__incoming_protocol_msgbus__.unsubscribe
-                    channel_client_two.change_state :detaching
-                    channel_client_two.change_state :detached
+                    channel_client_two.transition_state_machine :detaching
+                    channel_client_two.transition_state_machine :detached
                   end
                 end
               end
@@ -1565,6 +1585,7 @@ describe Ably::Realtime::Presence, :event_machine do
     context 'connection failure mid-way through a large member sync' do
       let(:members_count) { 400 }
       let(:sync_pages_received) { [] }
+      let(:client_options)  { default_options.merge(log_level: :error) }
 
       it 'resumes the SYNC operation', em_timeout: 15 do
         when_all(*members_count.times.map do |index|