ably 0.6.2 → 0.7.0

data/spec/acceptance/realtime/channel_spec.rb

@@ -1,211 +1,554 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'securerandom'
 
-describe Ably::Realtime::Channel do
-  include RSpec::EventMachine
+describe Ably::Realtime::Channel, :event_machine do
+  vary_by_protocol do
+    let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+    let(:client_options)  { default_options }
+
+    let(:client)       { Ably::Realtime::Client.new(client_options) }
+    let(:channel_name) { random_str }
+    let(:payload)      { random_str }
+    let(:channel)      { client.channel(channel_name) }
+    let(:messages)     { [] }
+
+    describe 'initialization' do
+      context 'with :connect_automatically option set to false on connection' do
+        let(:client) do
+          Ably::Realtime::Client.new(default_options.merge(connect_automatically: false))
+        end
 
-  [:msgpack, :json].each do |protocol|
-    context "over #{protocol}" do
-      let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+        it 'remains initialized when accessing a channel' do
+          client.channel('test')
+          EventMachine.add_timer(2) do
+            expect(client.connection).to be_initialized
+            stop_reactor
+          end
+        end
 
-      let(:client)       { Ably::Realtime::Client.new(default_options) }
-      let(:channel_name) { SecureRandom.hex(2) }
-      let(:payload)      { SecureRandom.hex(4) }
-      let(:channel)      { client.channel(channel_name) }
-      let(:messages)     { [] }
+        it 'opens a connection implicitly on #attach' do
+          client.channel('test').attach do
+            expect(client.connection).to be_connected
+            stop_reactor
+          end
+        end
 
-      it 'attaches to a channel' do
-        run_reactor do
+        it 'opens a connection implicitly when accessing #presence' do
+          client.channel('test').tap do |channel|
+            channel.on(:attached) do
+              expect(client.connection).to be_connected
+              stop_reactor
+            end
+            channel.presence
+          end
+        end
+      end
+    end
+
+    describe '#attach' do
+      it 'emits attaching then attached events' do
+        channel.once(:attaching) do
+          channel.once(:attached) do
+            stop_reactor
+          end
+        end
+
+        channel.attach
+      end
+
+      it 'ignores subsequent #attach calls but calls the success callback if provided' do
+        channel.once(:attaching) do
           channel.attach
-          channel.on(:attached) do
-            expect(channel.state).to eq(:attached)
+          channel.once(:attached) do
+            channel.attach do
+              stop_reactor
+            end
+          end
+        end
+
+        channel.attach
+      end
+
+      it 'attaches to a channel' do
+        channel.attach
+        channel.on(:attached) do
+          expect(channel.state).to eq(:attached)
+          stop_reactor
+        end
+      end
+
+      it 'attaches to a channel and calls the provided block' do
+        channel.attach do
+          expect(channel.state).to eq(:attached)
+          stop_reactor
+        end
+      end
+
+      it 'returns a Deferrable' do
+        expect(channel.attach).to be_a(EventMachine::Deferrable)
+        stop_reactor
+      end
+
+      it 'calls the Deferrable callback on success' do
+        channel.attach.callback do |channel|
+          expect(channel).to be_a(Ably::Realtime::Channel)
+          expect(channel.state).to eq(:attached)
+          stop_reactor
+        end
+      end
+
+      context 'when state is :failed' do
+        let(:client_options) { default_options.merge(log_level: :fatal) }
+
+        it 'reattaches' do
+          channel.attach do
+            channel.transition_state_machine :failed, RuntimeError.new
+            expect(channel).to be_failed
+            channel.attach do
+              expect(channel).to be_attached
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'when state is :detaching' do
+        it 'moves straight to attaching and skips detached' do
+          channel.once(:detaching) do
+            channel.once(:detached) { raise 'Detach should not have been reached' }
+
+            channel.once(:attaching) do
+              channel.once(:attached) do
+                channel.off
+                stop_reactor
+              end
+            end
+
+            channel.attach
+          end
+
+          channel.attach do
+            channel.detach
+          end
+        end
+      end
+
+      context 'with many connections and many channels on each simultaneously' do
+        let(:connection_count)       { 30 }
+        let(:channel_count)          { 10 }
+        let(:permutation_count)      { connection_count * channel_count }
+        let(:channel_connection_ids) { [] }
+
+        it 'attaches all channels', em_timeout: 15 do
+          connection_count.times.map do
+            Ably::Realtime::Client.new(default_options)
+          end.each do |client|
+            channel_count.times.map do |index|
+              client.channel("channel-#{index}").attach do
+                channel_connection_ids << "#{client.connection.id}:#{index}"
+                next unless channel_connection_ids.count == permutation_count
+
+                expect(channel_connection_ids.uniq.count).to eql(permutation_count)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      context 'failure as a result of insufficient key permissions' do
+        let(:restricted_client) do
+          Ably::Realtime::Client.new(default_options.merge(api_key: restricted_api_key, log_level: :fatal))
+        end
+        let(:restricted_channel) { restricted_client.channel("cannot_subscribe") }
+
+        it 'triggers failed event' do
+          restricted_channel.attach
+          restricted_channel.on(:failed) do |error|
+            expect(restricted_channel.state).to eq(:failed)
+            expect(error.status).to eq(401)
+            stop_reactor
+          end
+        end
+
+        it 'calls the errback of the returned Deferrable' do
+          restricted_channel.attach.errback do |channel, error|
+            expect(restricted_channel.state).to eq(:failed)
+            expect(error.status).to eq(401)
+            stop_reactor
+          end
+        end
+
+        it 'triggers an error event' do
+          restricted_channel.attach
+          restricted_channel.on(:error) do |error|
+            expect(restricted_channel.state).to eq(:failed)
+            expect(error.status).to eq(401)
+            stop_reactor
+          end
+        end
+
+        it 'updates the error_reason' do
+          restricted_channel.attach
+          restricted_channel.on(:failed) do
+            expect(restricted_channel.error_reason.status).to eq(401)
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    describe '#detach' do
+      it 'detaches from a channel' do
+        channel.attach do
+          channel.detach
+          channel.on(:detached) do
+            expect(channel.state).to eq(:detached)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'detaches from a channel and calls the provided block' do
+        channel.attach do |chan|
+          chan.detach do |detached_chan|
+            expect(detached_chan.state).to eq(:detached)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'emits :detaching then :detached events' do
+        channel.once(:detaching) do
+          channel.once(:detached) do
+            stop_reactor
+          end
+        end
+
+        channel.attach do
+          channel.detach
+        end
+      end
+
+      it 'returns a Deferrable' do
+        expect(channel.attach).to be_a(EventMachine::Deferrable)
+        stop_reactor
+      end
+
+      it 'calls the Deferrable callback on success' do
+        channel.attach do
+          channel.detach.callback do |channel|
+            expect(channel).to be_a(Ably::Realtime::Channel)
+            expect(channel.state).to eq(:detached)
             stop_reactor
           end
         end
       end
 
-      it 'attaches to a channel with a block' do
-        run_reactor do
+      context 'when state is :failed' do
+        let(:client_options) { default_options.merge(log_level: :fatal) }
+
+        it 'raises an exception' do
           channel.attach do
-            expect(channel.state).to eq(:attached)
+            channel.transition_state_machine :failed, RuntimeError.new
+            expect(channel).to be_failed
+            expect { channel.detach }.to raise_error Ably::Exceptions::StateChangeError
             stop_reactor
           end
         end
       end
 
-      it 'detaches from a channel with a block' do
-        run_reactor do
-          channel.attach do |chan|
-            chan.detach do |detached_chan|
-              expect(detached_chan.state).to eq(:detached)
-              stop_reactor
+      context 'when state is :attaching' do
+        it 'moves straight to :detaching state and skips :attached' do
+          channel.once(:attaching) do
+            channel.once(:attached) { raise 'Attached should never be reached' }
+
+            channel.once(:detaching) do
+              channel.once(:detached) do
+                stop_reactor
+              end
             end
+
+            channel.detach
           end
+
+          channel.attach
         end
       end
 
-      it 'publishes 3 messages once attached' do
-        run_reactor do
-          channel.attach do
-            3.times { channel.publish('event', payload) }
+      context 'when state is :detaching' do
+        it 'ignores subsequent #detach calls but calls the callback if provided' do
+          channel.once(:detaching) do
+            channel.detach
+            channel.once(:detached) do
+              channel.detach do
+                stop_reactor
+              end
+            end
           end
-          channel.subscribe do |message|
-            messages << message if message.data == payload
-            stop_reactor if messages.length == 3
+
+          channel.attach do
+            channel.detach
           end
         end
+      end
+    end
 
-        expect(messages.count).to eql(3)
+    describe 'channel recovery in :attaching state' do
+      context 'the transport is disconnected before the ATTACHED protocol message is received' do
+        skip 'attach times out and fails if not ATTACHED protocol message received'
+        skip 'channel is ATTACHED if ATTACHED protocol message is later received'
+        skip 'sends an ATTACH protocol message in response to a channel message being received on the attaching channel'
       end
+    end
 
-      it 'publishes 3 messages from queue before attached' do
-        run_reactor do
-          3.times { channel.publish('event', SecureRandom.hex) }
+    context '#publish' do
+      context 'when attached' do
+        it 'publishes messages' do
+          channel.attach do
+            3.times { channel.publish('event', payload) }
+          end
           channel.subscribe do |message|
-            messages << message if message.name == 'event'
-            stop_reactor if messages.length == 3
+            messages << message if message.data == payload
+            stop_reactor if messages.count == 3
           end
         end
-
-        expect(messages.count).to eql(3)
       end
 
-      it 'publishes 3 messages from queue before attached in a single protocol message' do
-        run_reactor do
-          3.times { channel.publish('event', SecureRandom.hex) }
+      context 'when not yet attached' do
+        it 'publishes queued messages once attached' do
+          3.times { channel.publish('event', random_str) }
           channel.subscribe do |message|
             messages << message if message.name == 'event'
-            stop_reactor if messages.length == 3
+            stop_reactor if messages.count == 3
           end
         end
 
-        # All 3 messages should be batched into a single Protocol Message by the client library
-        # message.id = "{protocol_message.id}:{protocol_message_index}"
+        it 'publishes queued messages within a single protocol message' do
+          3.times { channel.publish('event', random_str) }
+          channel.subscribe do |message|
+            messages << message if message.name == 'event'
+            next unless messages.length == 3
 
-        # Check that all messages share the same message_serial
-        message_id = messages.map { |msg| msg.id.split(':')[0] }
-        expect(message_id.uniq.count).to eql(1)
+            # All 3 messages should be batched into a single Protocol Message by the client library
+            # message.id = "{protocol_message.id}:{protocol_message_index}"
+            # Check that all messages share the same protocol_message.id
+            message_id = messages.map { |msg| msg.id.split(':')[0] }
+            expect(message_id.uniq.count).to eql(1)
 
-        # Check that all messages use message index 0,1,2
-        message_indexes = messages.map { |msg| msg.id.split(':')[1] }
-        expect(message_indexes).to include("0", "1", "2")
+            # Check that messages use index 0,1,2 in the ID
+            message_indexes = messages.map { |msg| msg.id.split(':')[1] }
+            expect(message_indexes).to include("0", "1", "2")
+            stop_reactor
+          end
+        end
       end
+    end
 
-      it 'subscribes and unsubscribes' do
-        run_reactor do
+    describe '#subscribe' do
+      context 'with an event argument' do
+        it 'subscribes for a single event' do
           channel.subscribe('click') do |message|
-            messages << message
+            expect(message.data).to eql('data')
+            stop_reactor
           end
-          channel.attach do
-            channel.unsubscribe('click')
-            channel.publish('click', 'data')
-            EventMachine.add_timer(2) do
-              stop_reactor
-              expect(messages.length).to eql(0)
-            end
+          channel.publish('click', 'data')
+        end
+      end
+
+      context 'with no event argument' do
+        it 'subscribes for all events' do
+          channel.subscribe do |message|
+            expect(message.data).to eql('data')
+            stop_reactor
           end
+          channel.publish('click', 'data')
         end
       end
 
-      it 'subscribes and unsubscribes from multiple channels' do
-        run_reactor do
-          click_callback = -> (message) { messages << message }
+      context 'many times with different event names' do
+        it 'filters events accordingly to each callback' do
+          click_callback = proc { |message| messages << message }
 
           channel.subscribe('click', &click_callback)
           channel.subscribe('move', &click_callback)
           channel.subscribe('press', &click_callback)
 
           channel.attach do
-            channel.unsubscribe('click')
-            channel.unsubscribe('move', &click_callback)
-            channel.unsubscribe('press') { this_callback_is_not_subscribed_so_ignored }
-
             channel.publish('click', 'data')
             channel.publish('move', 'data')
-            channel.publish('press', 'data')
+            channel.publish('press', 'data') do
+              EventMachine.add_timer(2) do
+                expect(messages.count).to eql(3)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+    end
+
+    describe '#unsubscribe' do
+      context 'with an event argument' do
+        it 'unsubscribes for a single event' do
+          channel.subscribe('click') { raise 'Should not have been called' }
+          channel.unsubscribe('click')
 
-            EventMachine.add_timer(2) do
+          channel.publish('click', 'data') do
+            EventMachine.add_timer(1) do
               stop_reactor
-              # Only the press subscribe callback should still be subscribed
-              expect(messages.length).to eql(1)
             end
           end
         end
       end
 
-      it 'opens many connections and then many channels simultaneously' do
-        run_reactor(15) do
-          count, connected_ids = 25, []
+      context 'with no event argument' do
+        it 'unsubscribes for a single event' do
+          channel.subscribe { raise 'Should not have been called' }
+          channel.unsubscribe
 
-          clients = count.times.map do
-            Ably::Realtime::Client.new(default_options)
+          channel.publish('click', 'data') do
+            EventMachine.add_timer(1) do
+              stop_reactor
+            end
           end
+        end
+      end
+    end
 
-          channels_opened = 0
-          open_channels_on_clients = Proc.new do
-            5.times.each do |channel|
-              clients.each do |client|
-                client.channel("channel-#{channel}").attach do
-                  channels_opened += 1
-                  if channels_opened == clients.count * 5
-                    expect(channels_opened).to eql(clients.count * 5)
-                    stop_reactor
-                  end
-                end
+    context 'when connection state changes to' do
+      context ':failed' do
+        let(:connection_error) { Ably::Exceptions::ConnectionError.new('forced failure', 500, 50000) }
+        let(:client_options)   { default_options.merge(log_level: :none) }
+
+        def fake_error(error)
+          client.connection.manager.error_received_from_server error
+        end
+
+        context 'an :attached channel' do
+          it 'transitions state to :failed' do
+            channel.attach do
+              channel.on(:failed) do |error|
+                expect(error).to eql(connection_error)
+                stop_reactor
               end
+              fake_error connection_error
             end
           end
 
-          clients.each do |client|
-            client.connection.on(:connected) do
-              connected_ids << client.connection.id
+          it 'triggers an error event on the channel' do
+            channel.attach do
+              channel.on(:error) do |error|
+                expect(error).to eql(connection_error)
+                stop_reactor
+              end
+              fake_error connection_error
+            end
+          end
 
-              if connected_ids.count == 25
-                expect(connected_ids.uniq.count).to eql(25)
-                open_channels_on_clients.call
+          it 'updates the channel error_reason' do
+            channel.attach do
+              channel.on(:failed) do |error|
+                expect(channel.error_reason).to eql(connection_error)
+                stop_reactor
               end
+              fake_error connection_error
             end
           end
         end
-      end
 
-      it 'opens many connections and attaches to channels before connected' do
-        run_reactor(15) do
-          count, connected_ids = 25, []
+        context 'a :detached channel' do
+          it 'remains in the :detached state' do
+            channel.attach do
+              channel.on(:failed) { raise 'Failed state should not have been reached' }
+              channel.on(:error)  { raise 'Error should not have been emitted' }
 
-          clients = count.times.map do
-            Ably::Realtime::Client.new(default_options)
+              channel.detach do
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_detached
+                  stop_reactor
+                end
+
+                fake_error connection_error
+              end
+            end
           end
+        end
 
-          channels_opened = 0
+        context 'a :failed channel' do
+          let(:original_error) { RuntimeError.new }
 
-          clients.each do |client|
-            5.times.each do |channel|
-              client.channel("channel-#{channel}").attach do
-                channels_opened += 1
-                if channels_opened == clients.count * 5
-                  expect(channels_opened).to eql(clients.count * 5)
+          it 'remains in the :failed state and ignores the failure error' do
+            channel.attach do
+              channel.on(:error) do
+                channel.on(:failed) { raise 'Failed state should not have been reached' }
+                channel.on(:error)  { raise 'Error should not have been emitted' }
+
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_failed
+                  expect(channel.error_reason).to eql(original_error)
                   stop_reactor
                 end
+
+                fake_error connection_error
               end
+
+              channel.transition_state_machine :failed, original_error
             end
           end
         end
       end
 
-      context 'attach failure' do
-        let(:restricted_client) do
-          Ably::Realtime::Client.new(default_options.merge(api_key: restricted_api_key))
+      context ':closed' do
+        context 'an :attached channel' do
+          it 'transitions state to :detached' do
+            channel.attach do
+              channel.on(:detached) do
+                stop_reactor
+              end
+              client.connection.close
+            end
+          end
         end
-        let(:restricted_channel) { restricted_client.channel("cannot_subscribe") }
 
-        it 'triggers failed event' do
-          run_reactor do
-            restricted_channel.attach
-            restricted_channel.on(:failed) do |error|
-              expect(restricted_channel.state).to eq(:failed)
-              expect(error.status).to eq(401)
-              stop_reactor
+        context 'a :detached channel' do
+          it 'remains in the :detached state' do
+            channel.attach do
+              channel.detach do
+                channel.on(:detached) { raise 'Detached state should not have been reached' }
+                channel.on(:error)    { raise 'Error should not have been emitted' }
+
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_detached
+                  stop_reactor
+                end
+
+                client.connection.close
+              end
+            end
+          end
+        end
+
+        context 'a :failed channel' do
+          let(:original_error) { RuntimeError.new }
+          let(:client_options)   { default_options.merge(log_level: :fatal) }
+
+          it 'remains in the :failed state and retains the error_reason' do
+            channel.attach do
+              channel.once(:error) do
+                channel.on(:detached) { raise 'Detached state should not have been reached' }
+                channel.on(:error)    { raise 'Error should not have been emitted' }
+
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_failed
+                  expect(channel.error_reason).to eql(original_error)
+                  stop_reactor
+                end
+
+                client.connection.close
+              end
+
+              channel.transition_state_machine :failed, original_error
             end
           end
         end
@@ -213,5 +556,3 @@ describe Ably::Realtime::Channel do
     end
   end
 end
-
-