ably-rest 0.7.1 → 0.7.3

data/lib/submodules/ably-ruby/lib/ably/util/pub_sub.rb

@@ -0,0 +1,43 @@
+module Ably::Util
+  # PubSub class provides methods to publish & subscribe to events, with methods and naming
+  # intentionally different to EventEmitter as it is intended for private message handling
+  # within the client library.
+  #
+  # @example
+  #   class Channel
+  #     def messages
+  #       @messages ||= PubSub.new
+  #     end
+  #   end
+  #
+  #   channel = Channel.new
+  #   channel.messages.subscribe(:event) { |name| puts "Event message #{name} received" }
+  #   channel.messages.publish :event, "Test"
+  #   #=> "Event message Test received"
+  #   channel.messages.remove :event
+  #
+  class PubSub
+    include Ably::Modules::EventEmitter
+
+    # Ensure new PubSub object does not share class instance variables
+    def self.new(options = {})
+      Class.new(PubSub).allocate.tap do |pub_sub_object|
+        pub_sub_object.send(:initialize, options)
+      end
+    end
+
+    def inspect
+      "<#PubSub: @event_emitter_coerce_proc: #{self.class.event_emitter_coerce_proc.inspect}\n @callbacks: #{callbacks}>"
+    end
+
+    def initialize(options = {})
+      self.class.instance_eval do
+        configure_event_emitter options
+
+        alias_method :subscribe, :on
+        alias_method :publish, :trigger
+        alias_method :unsubscribe, :off
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -0,0 +1,3 @@
+module Ably
+  VERSION = '0.7.3'
+end

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

@@ -0,0 +1,154 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Realtime::Channel, '#history', :event_machine do
+  vary_by_protocol do
+    let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
+
+    let(:client)       { Ably::Realtime::Client.new(default_options) }
+    let(:channel)      { client.channel(channel_name) }
+
+    let(:client2)      { Ably::Realtime::Client.new(default_options) }
+    let(:channel2)     { client2.channel(channel_name) }
+
+    let(:channel_name) { "persisted:#{random_str(2)}" }
+    let(:payload)      { random_str }
+    let(:messages)     { [] }
+
+    let(:options)      { { :protocol => :json } }
+
+    it 'returns a Deferrable' do
+      channel.publish('event', payload) do |message|
+        history = channel.history
+        expect(history).to be_a(EventMachine::Deferrable)
+        history.callback do |messages|
+          expect(messages.count).to eql(1)
+          expect(messages).to be_a(Ably::Models::PaginatedResource)
+          stop_reactor
+        end
+      end
+    end
+
+    context 'with a single client publishing and receiving' do
+      it 'retrieves real-time history' do
+        channel.publish('event', payload) do |message|
+          channel.history do |history|
+            expect(history.length).to eql(1)
+            expect(history[0].data).to eql(payload)
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context 'with two clients publishing messages on the same channel' do
+      it 'retrieves real-time history on both channels' do
+        channel.publish('event', payload) do |message|
+          channel2.publish('event', payload) do |message|
+            channel.history do |history|
+              expect(history.length).to eql(2)
+              expect(history.map(&:data).uniq).to eql([payload])
+
+              channel2.history do |history_2|
+                expect(history_2.length).to eql(2)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'with lots of messages published with a single client and channel' do
+      let(:messages_sent)   { 30 }
+      let(:rate_per_second) { 10 }
+      let(:limit)           { 15 }
+
+      def ensure_message_history_direction_and_paging_is_correct(direction)
+        channel.history(direction: direction, limit: limit) do |history|
+          expect(history.length).to eql(limit)
+          limit.times do |index|
+            expect(history[index].data).to eql("history#{index}")
+          end
+
+          history.next_page do |history|
+            expect(history.length).to eql(limit)
+            limit.times do |index|
+              expect(history[index].data).to eql("history#{index + limit}")
+            end
+            expect(history.last_page?).to eql(true)
+
+            stop_reactor
+          end
+        end
+      end
+
+      context 'as one ProtocolMessage' do
+        it 'retrieves history forwards with pagination through :limit option' do
+          messages_sent.times do |index|
+            channel.publish('event', "history#{index}") do
+              next unless index == messages_sent - 1
+              ensure_message_history_direction_and_paging_is_correct :forwards
+            end
+          end
+        end
+
+        it 'retrieves history backwards with pagination through :limit option' do
+          messages_sent.times.to_a.reverse.each do |index|
+            channel.publish('event', "history#{index}") do
+              next unless index == 0
+              ensure_message_history_direction_and_paging_is_correct :backwards
+            end
+          end
+        end
+      end
+
+      context 'in multiple ProtocolMessages', em_timeout: (30 / 10) + 5 do
+        it 'retrieves limited history forwards with pagination' do
+          messages_sent.times do |index|
+            EventMachine.add_timer(index.to_f / rate_per_second) do
+              channel.publish('event', "history#{index}") do
+                next unless index == messages_sent - 1
+                ensure_message_history_direction_and_paging_is_correct :forwards
+              end
+            end
+          end
+        end
+
+        it 'retrieves limited history backwards with pagination' do
+          messages_sent.times.to_a.reverse.each do |index|
+            EventMachine.add_timer((messages_sent - index).to_f / rate_per_second) do
+              channel.publish('event', "history#{index}") do
+                next unless index == 0
+                ensure_message_history_direction_and_paging_is_correct :backwards if index == 0
+              end
+            end
+          end
+        end
+      end
+
+      context 'and REST history' do
+        let(:batches) { 3 }
+        let(:messages_per_batch) { 10 }
+
+        it 'return the same results with unique matching message IDs' do
+          batches.times do |batch|
+            EventMachine.add_timer(batch.to_f / batches.to_f) do
+              messages_per_batch.times { channel.publish('event', 'data') }
+            end
+          end
+
+          channel.subscribe('event') do |message|
+            messages << message
+            if messages.count == batches * messages_per_batch
+              channel.history do |history|
+                expect(history.map(&:id).sort).to eql(messages.map(&:id).sort)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,558 @@
+# encoding: utf-8
+require 'spec_helper'
+
+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
+
+        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
+
+        it 'opens a connection implicitly on #attach' do
+          client.channel('test').attach do
+            expect(client.connection).to be_connected
+            stop_reactor
+          end
+        end
+
+        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.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
+
+      context 'when state is :failed' do
+        let(:client_options) { default_options.merge(log_level: :fatal) }
+
+        it 'raises an exception' do
+          channel.attach do
+            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
+
+      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
+
+      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.attach do
+            channel.detach
+          end
+        end
+      end
+    end
+
+    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
+
+    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.data == payload
+            stop_reactor if messages.count == 3
+          end
+        end
+      end
+
+      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.count == 3
+          end
+        end
+
+        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
+
+            # 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 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
+
+    describe '#subscribe' do
+      context 'with an event argument' do
+        it 'subscribes for a single event' do
+          channel.subscribe('click') do |message|
+            expect(message.data).to eql('data')
+            stop_reactor
+          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
+
+      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.publish('click', 'data')
+            channel.publish('move', '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')
+
+          channel.publish('click', 'data') do
+            EventMachine.add_timer(1) do
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'with no event argument' do
+        it 'unsubscribes for a single event' do
+          channel.subscribe { raise 'Should not have been called' }
+          channel.unsubscribe
+
+          channel.publish('click', 'data') do
+            EventMachine.add_timer(1) do
+              stop_reactor
+            end
+          end
+        end
+      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
+
+          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
+
+          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
+
+        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' }
+
+              channel.detach do
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_detached
+                  stop_reactor
+                end
+
+                fake_error connection_error
+              end
+            end
+          end
+        end
+
+        context 'a :failed channel' do
+          let(:original_error) { RuntimeError.new }
+
+          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 ':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
+
+        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
+      end
+    end
+  end
+end