ably 1.1.7 → 1.1.8

data/spec/acceptance/realtime/channel_spec.rb

@@ -750,6 +750,107 @@ describe Ably::Realtime::Channel, :event_machine do
         end
       end
 
+      describe '#(RTL17)' do
+        context 'when channel is initialized' do
+          it 'sends messages only on attach' do
+            expect(channel).to be_initialized
+            channel.publish('event', payload)
+
+            channel.subscribe do |message|
+              stop_reactor if message.data == payload && channel.attached?
+            end
+
+            channel.attach
+          end
+        end
+
+        context 'when channel is attaching' do
+          it 'sends messages only on attach' do
+            channel.publish('event', payload)
+
+            sent_message = nil
+            channel.subscribe do |message|
+              return if message.data != payload
+              sent_message = message
+
+              stop_reactor if channel.attached?
+            end
+
+            channel.on(:attaching) do
+              expect(channel).to be_attaching
+              expect(sent_message).to be_nil
+            end
+
+            channel.attach
+          end
+        end
+
+        context 'when channel is detaching' do
+          it 'stops sending message' do
+            sent_message = nil
+            event_published = false
+            channel.subscribe do |message|
+              sent_message = message if message.data == payload
+            end
+
+            channel.on(:detaching) do
+              channel.publish('event', payload)
+              event_published = true
+            end
+
+            channel.on(:detaching) do
+              EventMachine.next_tick do
+                expect(sent_message).to be_nil
+                stop_reactor if event_published
+              end
+            end
+
+            channel.attach do
+              channel.detach
+            end
+          end
+        end
+
+        context 'when channel is detached' do
+          it 'stops sending message' do
+            sent_message = nil
+            event_published = false
+            channel.subscribe do |message|
+              sent_message = message if message.data == payload
+            end
+
+            channel.on(:detaching) do
+              channel.publish('event', payload)
+              event_published = true
+            end
+
+            channel.on(:detached) do
+              expect(sent_message).to be_nil
+              stop_reactor if event_published
+            end
+
+            channel.attach do
+              channel.detach
+            end
+          end
+        end
+
+        context 'when channel is failed' do
+          it 'errors when trying to send a message' do
+            channel.once(:failed) do
+              channel.publish('event', payload).errback do |error|
+                expect(error).to be_a(Ably::Exceptions::ChannelInactive)
+                stop_reactor
+              end
+            end
+
+            channel.attach do
+              channel.transition_state_machine(:failed)
+            end
+          end
+        end
+      end
+
       context 'when channel is not attached in state Initializing (#RTL6c1)' do
         it 'publishes messages immediately and does not implicitly attach (#RTL6c1)' do
           sub_channel.attach do
@@ -1181,7 +1282,7 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       context 'with more than allowed messages in a single publish' do
-        let(:channel_name) { random_str }
+        65536
 
         it 'rejects the publish' do
           messages = (Ably::Realtime::Connection::MAX_PROTOCOL_MESSAGE_BATCH_SIZE + 1).times.map do
@@ -1405,15 +1506,98 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       context 'message size exceeded (#TO3l8)' do
-        let(:message) { 'x' * 700000 }
-
         let(:client) { auto_close Ably::Realtime::Client.new(client_options) }
         let(:channel) { client.channels.get(channel_name) }
 
-        it 'should not allow to send a message' do
-          channel.publish('event', message).errback do |error|
-            expect(error).to be_instance_of(Ably::Exceptions::MaxMessageSizeExceeded)
-            stop_reactor
+        context 'and max_message_size is default (65536 bytes)' do
+          let(:channel_name) { random_str }
+          let(:max_message_size) { 65536 }
+
+          it 'should allow to send a message (32 bytes)' do
+            client.connection.once(:connected) do
+              channel.subscribe('event') do |msg|
+                expect(msg.data).to eq('x' * 32)
+                stop_reactor
+              end
+              channel.publish('event', 'x' * 32)
+            end
+          end
+
+          it 'should not allow to send a message (700000 bytes)' do
+            client.connection.once(:connected) do
+              connection_details = Ably::Models::ConnectionDetails.new(
+                client.connection.details.attributes.attributes.merge('maxMessageSize' => max_message_size)
+              )
+              client.connection.set_connection_details(connection_details)
+              expect(client.connection.details.max_message_size).to eq(65536)
+              channel.publish('event', 'x' * 700000).errback do |error|
+                expect(error).to be_instance_of(Ably::Exceptions::MaxMessageSizeExceeded)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'and max_message_size is customized (11 bytes)' do
+          let(:max_message_size) { 11 }
+
+          context 'and the message size is 30 bytes' do
+            let(:channel_name) { random_str }
+
+            it 'should not allow to send a message' do
+              client.connection.once(:connected) do
+                connection_details = Ably::Models::ConnectionDetails.new(
+                  client.connection.details.attributes.attributes.merge('maxMessageSize' => max_message_size)
+                )
+                client.connection.set_connection_details(connection_details)
+                expect(client.connection.details.max_message_size).to eq(11)
+                channel.publish('event', 'x' * 30).errback do |error|
+                  expect(error).to be_instance_of(Ably::Exceptions::MaxMessageSizeExceeded)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+
+        context 'and max_message_size is nil' do
+          let(:max_message_size) { nil }
+
+          context 'and the message size is 30 bytes' do
+            let(:channel_name) { random_str }
+
+            it 'should allow to send a message' do
+              client.connection.once(:connected) do
+                connection_details = Ably::Models::ConnectionDetails.new(
+                  client.connection.details.attributes.attributes.merge('maxMessageSize' => max_message_size)
+                )
+                client.connection.set_connection_details(connection_details)
+                expect(client.connection.details.max_message_size).to eq(65536)
+                channel.subscribe('event') do |msg|
+                  expect(msg.data).to eq('x' * 30)
+                  stop_reactor
+                end
+                channel.publish('event', 'x' * 30)
+              end
+            end
+          end
+
+          context 'and the message size is 65537 bytes' do
+            let(:channel_name) { random_str }
+
+            it 'should not allow to send a message' do
+              client.connection.once(:connected) do
+                connection_details = Ably::Models::ConnectionDetails.new(
+                  client.connection.details.attributes.attributes.merge('maxMessageSize' => max_message_size)
+                )
+                client.connection.set_connection_details(connection_details)
+                expect(client.connection.details.max_message_size).to eq(65536)
+                channel.publish('event', 'x' * 65537).errback do |error|
+                  expect(error).to be_instance_of(Ably::Exceptions::MaxMessageSizeExceeded)
+                  stop_reactor
+                end
+              end
+            end
           end
         end
       end
@@ -2224,6 +2408,27 @@ describe Ably::Realtime::Channel, :event_machine do
             channel.transition_state_machine! :suspended
           end
         end
+
+        context 'when connection is no longer connected' do
+          it 'will not attempt to reattach (#RTL13c)' do
+            channel.attach do
+              connection.once(:closing) do
+                channel.once(:attaching) do |state_change|
+                  raise 'Channel should not attempt to reattach'
+                end
+
+                channel.transition_state_machine! :suspended
+              end
+
+              connection.once(:closed) do
+                expect(channel).to be_suspended
+                stop_reactor
+              end
+
+              connection.close
+            end
+          end
+        end
       end
 
       context 'and channel is attaching' do

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -570,7 +570,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       end
 
       context 'when DISCONNECTED ProtocolMessage received from the server' do
-        it 'reconnects automatically and immediately' do
+        it 'reconnects automatically and immediately (#RTN15a)' do
           fail_if_suspended_or_failed
 
           connection.once(:connected) do
@@ -590,6 +590,61 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
         end
 
+        context 'when protocolMessage contains token error' do
+          context "library does not have a means to renew the token (#RTN15h1)" do
+            let(:auth_url) { 'https://echo.ably.io/createJWT' }
+            let(:token) { Faraday.get("#{auth_url}?keyName=#{key_name}&keySecret=#{key_secret}").body }
+            let(:client_options) { default_options.merge(token: token, log_level: :none) }
+
+            let(:error_message) { 'error_message' }
+
+            it 'moves connection state to failed'  do
+              connection.on(:failed) do |connection_state_change|
+                expect(connection.error_reason.message).to eq(error_message)
+                stop_reactor
+              end
+
+              connection.on(:connected) do
+                protocol_message = Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Disconnected.to_i, error: { code: 40140, message: error_message })
+                connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
+              end
+
+              connection.connect
+            end
+          end
+
+          context "library have a means to renew the token (#RTN15h2)" do
+            let(:client_options) { default_options.merge(log_level: :none) }
+            let(:error_message) { 'error_message' }
+
+            def send_disconnect_message
+              protocol_message = Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Disconnected.to_i, error: { code: 40140, message: error_message })
+              connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
+            end
+
+            it 'attempts to reconnect'  do
+              connection.on(:failed) do |connection_state_change|
+                raise "Connection shouldn't be failed"
+              end
+
+              connection.on(:connected) do
+                connection.once(:connecting) do
+                  connection.once(:disconnected) do
+                    expect(connection.error_reason.message).to eq(error_message)
+                    stop_reactor
+                  end
+
+                  send_disconnect_message
+                end
+
+                send_disconnect_message
+              end
+
+              connection.connect
+            end
+          end
+        end
+
         context 'connection state freshness is monitored' do
           it 'resumes connections when disconnected within the connection_state_ttl period (#RTN15g)' do
             connection.once(:connected) do

data/spec/acceptance/realtime/connection_spec.rb

@@ -482,6 +482,118 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
 
+      context 'when explicitly reconnecting disconnected/suspended connection in retry (#RTN11c)' do
+        let(:close_connection_proc) do
+          lambda 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
+        end
+
+        context 'when suspended' do
+          let(:suspended_retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: 0.02,
+              suspended_retry_timeout: suspended_retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'reconnects immediately' do
+            connection.once(:connecting) { close_connection_proc.call }
+
+            connection.on(:suspended) do |connection_state_change|
+              if connection_state_change.retry_in.zero?
+                # Exhausting immediate retries
+                connection.once(:connecting) { close_connection_proc.call }
+              else
+                suspended_at = Time.now.to_f
+                connection.on(:connected) do
+                  expect(connection_state_change.retry_in).to eq(suspended_retry_timeout)
+                  expect(connection.state).to eq(:connected)
+                  expect(Time.now.to_f).to be_within(4).of(suspended_at)
+                  stop_reactor
+                end
+              end
+
+              connection.connect
+            end
+
+            connection.connect
+          end
+        end
+
+        context 'when disconnected' do
+          let(:retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: retry_timeout,
+              suspended_retry_timeout: retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'reconnects immediately' do
+            connection.once(:connected) do
+              connection.on(:disconnected) do |connection_state_change|
+                disconnected_at = Time.now.to_f
+                connection.on(:connected) do
+                  if connection_state_change.retry_in.zero?
+                    # Exhausting immediate retries
+                    close_connection_proc.call
+                  else
+                    expect(connection_state_change.retry_in).to eq(retry_timeout)
+                    expect(connection.state).to eq(:connected)
+                    expect(Time.now.to_f).to be_within(4).of(disconnected_at)
+                    stop_reactor
+                  end
+                end
+                connection.connect
+              end
+
+              close_connection_proc.call
+            end
+
+            connection.connect
+          end
+        end
+      end
+
+      context 'when reconnecting a failed connection' do
+        let(:channel) { client.channel(random_str) }
+        let(:client_options) { default_options.merge(log_level: :none) }
+
+        it 'transitions all channels state to initialized and cleares error_reason' do
+          connection.on(:failed) do |connection_state_change|
+            expect(connection.error_reason).to be_a(Ably::Exceptions::BaseAblyException)
+            expect(channel.error_reason).to be_a(Ably::Exceptions::BaseAblyException)
+            expect(channel).to be_failed
+
+            connection.on(:connected) do
+              expect(connection.error_reason).to eq(nil)
+              expect(channel).to be_initialized
+              expect(channel.error_reason).to eq(nil)
+              stop_reactor
+            end
+
+            connection.connect
+          end
+
+          connection.connect do
+            channel.attach do
+              error = Ably::Exceptions::ConnectionFailed.new('forced failure', 500, 50000)
+              client.connection.manager.error_received_from_server error
+            end
+          end
+        end
+      end
+
       context 'with invalid auth details' do
         let(:client_options) { default_options.merge(key: 'this.is:invalid', log_level: :none) }
 
@@ -693,6 +805,18 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     context '#close' do
+      let(:close_connection_proc) do
+        lambda 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
+      end
+
       it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         connection.connect do
           expect(connection.close).to be_a(Ably::Util::SafeDeferrable)
@@ -754,6 +878,56 @@ describe Ably::Realtime::Connection, :event_machine do
           end
         end
 
+        context ':connecting RTN12f' do
+          context ":connected does not arrive when trying to close" do
+            it 'moves to closed' do
+              connection.on(:closed) do |state_change|
+                state_changes = connection.state_history.map { |t| t[:state].to_sym }
+
+                expect(state_changes).to eq([:connecting, :closing, :closed])
+                stop_reactor
+              end
+
+              connection.on(:connecting) do
+                connection.close
+                connection.__outgoing_protocol_msgbus__.unsubscribe
+              end
+
+              connection.connect
+            end
+          end
+
+          context ":connected arrive when trying to close" do
+            let(:protocol_message_attributes) do
+              {
+                action: Ably::Models::ProtocolMessage::ACTION.Connected.to_i,
+                connection_serial: 55,
+                connection_details: {
+                  max_idle_interval: 2 * 1000
+                }
+              }
+            end
+
+            it 'moves to connected and then to closed' do
+              connection.on(:closed) do |state_change|
+                state_changes = connection.state_history.map { |t| t[:state].to_sym }
+
+                expect(state_changes).to eq([:connecting, :connected, :closing, :closed])
+                stop_reactor
+              end
+
+              connection.on(:connecting) do
+                connection.__outgoing_protocol_msgbus__.unsubscribe
+
+                connection.__incoming_protocol_msgbus__.publish :protocol_message, Ably::Models::ProtocolMessage.new(protocol_message_attributes)
+                connection.close
+              end
+
+              connection.connect
+            end
+          end
+        end
+
         context ':connected' do
           it 'changes the connection state to :closing and waits for the server to confirm connection is :closed with a ProtocolMessage' do
             connection.on(:connected) do
@@ -800,6 +974,81 @@ describe Ably::Realtime::Connection, :event_machine do
             end
           end
         end
+
+        context ':suspended RTN12d' do
+          let(:suspended_retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: 0.02,
+              suspended_retry_timeout: suspended_retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'immediatly closes connection' do
+            connection.on(:connecting) { close_connection_proc.call }
+            connection.on(:suspended) do |connection_state_change|
+              if connection_state_change.retry_in.zero?
+                # Exhausting immediate retries
+                connection.once(:connecting) { close_connection_proc.call }
+              else
+                suspended_at = Time.now.to_f
+                connection.on(:closed) do
+                  expect(connection_state_change.retry_in).to eq(suspended_retry_timeout)
+                  expect(connection.state).to eq(:closed)
+                  expect(Time.now.to_f).to be_within(4).of(suspended_at)
+                  stop_reactor
+                end
+
+                connection.close
+              end
+
+              connection.connect
+            end
+
+            connection.connect
+          end
+        end
+
+        context ':disconnected RTN12d' do
+          let(:retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: retry_timeout,
+              suspended_retry_timeout: retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'immediatly closes connection' do
+            connection.once(:connected) do
+              connection.on(:disconnected) do |connection_state_change|
+                disconnected_at = Time.now.to_f
+                connection.on(:connected) do
+                  if connection_state_change.retry_in.zero?
+                    # Exhausting immediate retries
+                    close_connection_proc.call
+                  else
+                    connection.once(:closed) do
+                      expect(connection_state_change.retry_in).to eq(retry_timeout)
+                      expect(connection.state).to eq(:closed)
+                      expect(Time.now.to_f).to be_within(4).of(disconnected_at)
+                      stop_reactor
+                    end
+
+                    connection.close
+                  end
+                end
+
+                connection.connect
+              end
+
+              close_connection_proc.call
+            end
+
+            connection.connect
+          end
+        end
       end
     end
 

data/spec/acceptance/realtime/presence_spec.rb

@@ -2634,7 +2634,24 @@ describe Ably::Realtime::Presence, :event_machine do
       end
     end
 
-    context 'channel state side effects' do
+    context 'channel state side effects (RTP5)' do
+      context 'channel transitions to the ATTACHED state (RTP5b)' do
+        it 'all queued presence messages are sent' do
+          channel_client_one.on(:attached) do
+            client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+              if protocol_message.action == :presence
+                expect(protocol_message.action).to eq(:presence)
+                stop_reactor
+              end
+            end
+          end
+
+          presence_client_one.enter do
+            channel_client_one.attach
+          end
+        end
+      end
+
       context 'channel transitions to the FAILED state' do
         let(:anonymous_client) { auto_close Ably::Realtime::Client.new(client_options.merge(log_level: :fatal)) }
         let(:client_one)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: client_one_id, log_level: :fatal)) }