ably 0.1.5 → 0.1.6

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe Ably::Realtime::Channel do
+  include RSpec::EventMachine
+
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
+
+      let(:client) do
+        Ably::Realtime::Client.new(default_options)
+      end
+      let(:channel) { client.channel(channel_name) }
+
+      let(:client2) do
+        Ably::Realtime::Client.new(default_options)
+      end
+      let(:channel2) { client2.channel(channel_name) }
+
+      let(:channel_name) { "persisted:#{SecureRandom.hex(2)}" }
+      let(:payload) { SecureRandom.hex(4) }
+      let(:messages) { [] }
+
+      let(:options) { { :protocol => :json } }
+
+      it 'retrieves real-time history' do
+        run_reactor do
+          channel.publish('event', payload) do |message|
+            history = channel.history
+            expect(history.length).to eql(1)
+            expect(history[0].data).to eql(payload)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'retrieves real-time history across two channels' do
+        run_reactor do
+          channel.publish('event', payload) do |message|
+            channel2.publish('event', payload) do |message|
+              history = channel2.history
+              expect(history.length).to eql(2)
+              expect(history.map(&:data).uniq).to eql([payload])
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'with multiple messages' do
+        let(:messages_sent) { 20 }
+        let(:limit) { 10 }
+
+        def check_limited_history(direction)
+          history = channel.history(direction: direction, limit: limit)
+          expect(history.length).to eql(limit)
+          limit.times do |index|
+            expect(history[index].data).to eql("history#{index}")
+          end
+
+          history = history.next_page
+
+          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
+
+        context 'as one ProtocolMessage' do
+          it 'retrieves limited history forwards with pagination' do
+            run_reactor(5) do
+              messages_sent.times do |index|
+                channel.publish('event', "history#{index}") do
+                  check_limited_history :forwards if index == messages_sent - 1
+                end
+              end
+            end
+          end
+
+          it 'retrieves limited history backwards with pagination' do
+            run_reactor(5) do
+              messages_sent.times.to_a.reverse.each do |index|
+                channel.publish('event', "history#{index}") do
+                  check_limited_history :backwards if index == messages_sent - 1
+                end
+              end
+            end
+          end
+        end
+
+        context 'in multiple ProtocolMessages' do
+          it 'retrieves limited history forwards with pagination' do
+            run_reactor(5) do
+              messages_sent.times do |index|
+                EventMachine.add_timer(index.to_f / 10) do
+                  channel.publish('event', "history#{index}") do
+                    check_limited_history :forwards if index == messages_sent - 1
+                  end
+                end
+              end
+            end
+          end
+
+          it 'retrieves limited history backwards with pagination' do
+            run_reactor(5) do
+              messages_sent.times.to_a.reverse.each do |index|
+                EventMachine.add_timer((messages_sent - index).to_f / 10) do
+                  channel.publish('event', "history#{index}") do
+                    check_limited_history :backwards if index == 0
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        skip 'ensure REST history message IDs match ProtocolMessage wrapped message IDs via Realtime'
+      end
+    end
+  end
+end

data/spec/acceptance/realtime/channel_spec.rb

@@ -4,83 +4,155 @@ require 'securerandom'
 describe Ably::Realtime::Channel do
   include RSpec::EventMachine
 
-  let(:client) do
-    Ably::Realtime::Client.new(api_key: api_key, environment: environment)
-  end
-  let(:channel_name) { SecureRandom.hex(2) }
-  let(:payload) { SecureRandom.hex(4) }
-
-  it 'attachs to a channel' do
-    attached = false
-
-    run_reactor do
-      channel = client.channel(channel_name)
-      channel.attach
-      channel.on(:attached) do
-        expect(channel.state).to eq(:attached)
-        attached = true
-        stop_reactor
-      end
-    end
-
-    expect(attached).to eql(true)
-  end
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
 
-  it 'publishes 3 messages once attached' do
-    messages = []
-
-    run_reactor do
-      channel = client.channel(channel_name)
-      channel.attach
-      channel.on(:attached) do
-        3.times { channel.publish('event', payload) }
+      let(:client) do
+        Ably::Realtime::Client.new(default_options)
       end
-      channel.subscribe do |message|
-        messages << message if message.data == payload
-        stop_reactor if messages.length == 3
+      let(:channel_name) { SecureRandom.hex(2) }
+      let(:payload) { SecureRandom.hex(4) }
+      let(:channel) { client.channel(channel_name) }
+      let(:messages) { [] }
+
+      it 'attaches to a channel' do
+        run_reactor do
+          channel.attach
+          channel.on(:attached) do
+            expect(channel.state).to eq(:attached)
+            stop_reactor
+          end
+        end
       end
-    end
 
-    expect(messages.count).to eql(3)
-  end
+      it 'attaches to a channel with a block' do
+        run_reactor do
+          channel.attach do
+            expect(channel.state).to eq(:attached)
+            stop_reactor
+          end
+        end
+      end
 
-  it 'publishes 3 messages from queue before attached' do
-    messages = []
+      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
+            end
+          end
+        end
+      end
 
-    run_reactor do
-      channel = client.channel(channel_name)
-      3.times { channel.publish('event', SecureRandom.hex) }
-      channel.subscribe do |message|
-        messages << message if message.name == 'event'
-        stop_reactor if messages.length == 3
+      it 'publishes 3 messages once attached' do
+        run_reactor 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.length == 3
+          end
+        end
+
+        expect(messages.count).to eql(3)
       end
-    end
 
-    expect(messages.count).to eql(3)
-  end
+      it 'publishes 3 messages from queue before attached' do
+        run_reactor do
+          3.times { channel.publish('event', SecureRandom.hex) }
+          channel.subscribe do |message|
+            messages << message if message.name == 'event'
+            stop_reactor if messages.length == 3
+          end
+        end
 
-  it 'publishes 3 messages from queue before attached in a single protocol message' do
-    messages = []
+        expect(messages.count).to eql(3)
+      end
 
-    run_reactor do
-      channel = client.channel(channel_name)
-      3.times { channel.publish('event', SecureRandom.hex) }
-      channel.subscribe do |message|
-        messages << message if message.name == 'event'
-        stop_reactor if messages.length == 3
+      it 'publishes 3 messages from queue before attached in a single protocol message' do
+        run_reactor do
+          3.times { channel.publish('event', SecureRandom.hex) }
+          channel.subscribe do |message|
+            messages << message if message.name == 'event'
+            stop_reactor if messages.length == 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}"
+
+        # 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)
+
+        # 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")
       end
-    end
 
-    # All 3 messages should be batched into a single Protocol Message by the client library
-    # message_id = "{connection_id}:{message_serial}:{protocol_message_index}"
+      it 'subscribes and unsubscribes' do
+        run_reactor do
+          channel.subscribe('click') do |message|
+            messages << message
+          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
+          end
+        end
+      end
 
-    # Check that all messages share the same message_serial
-    message_serials = messages.map { |msg| msg.message_id.split(':')[1] }
-    expect(message_serials.uniq).to eql(["1"])
+      it 'subscribes and unsubscribes from multiple channels' do
+        run_reactor do
+          click_callback = -> (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')
+
+            EventMachine.add_timer(2) do
+              stop_reactor
+              # Only the press subscribe callback should still be subscribed
+              expect(messages.length).to eql(1)
+            end
+          end
+        end
+      end
 
-    # Check that all messages use message index 0,1,2
-    message_indexes = messages.map { |msg| msg.message_id.split(':')[2] }
-    expect(message_indexes).to include("0", "1", "2")
+      context 'attach failure' do
+        let(:restricted_client) do
+          Ably::Realtime::Client.new(default_options.merge(api_key: restricted_api_key))
+        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_code).to eq(401)
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
   end
 end
 

data/spec/acceptance/realtime/connection_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Ably::Realtime::Connection do
+  include RSpec::EventMachine
+
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:client) do
+        Ably::Realtime::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      end
+
+      subject { client.connection }
+
+      it 'connects automatically' do
+        run_reactor do
+          subject.on(:connected) do
+            expect(subject.state).to eq(:connected)
+            stop_reactor
+          end
+        end
+      end
+
+      context 'initialization phases' do
+        let(:phases) { [:initialized, :connecting, :connected] }
+        let(:events_triggered) { [] }
+
+        it 'are triggered in order' do
+          test_expectation = Proc.new do
+            expect(events_triggered).to eq(phases)
+            stop_reactor
+          end
+
+          run_reactor do
+            phases.each do |phase|
+              subject.on(phase) do
+                events_triggered << phase
+                test_expectation.call if events_triggered.length == phases.length
+              end
+            end
+          end
+        end
+      end
+
+      skip '#closed disconnects and closes the connection once timeout is reached'
+
+      specify '#closed disconnects and closes the connection gracefully' do
+        run_reactor(8) do
+          subject.close
+          subject.on(:closed) do
+            expect(subject.state).to eq(:closed)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'receives a heart beat' do
+        run_reactor(20) do
+          subject.on(:connected) do
+            subject.__incoming_protocol_msgbus__.subscribe(:message) do |protocol_message|
+              if protocol_message.action == :heartbeat
+                expect(protocol_message.action).to eq(:heartbeat)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      skip 'connects, closes gracefully and reconnects on #connect'
+
+      it 'connects, closes then connection when timeout is reaached and reconnects on #connect' do
+        run_reactor(15) do
+          subject.connect do
+            connection_id = subject.id
+            subject.close do
+              subject.connect do
+                expect(subject.id).to_not eql(connection_id)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/realtime/message_spec.rb

@@ -4,80 +4,66 @@ require 'securerandom'
 describe 'Ably::Realtime::Channel Messages' do
   include RSpec::EventMachine
 
-  let(:client) do
-    Ably::Realtime::Client.new(options.merge(api_key: api_key, environment: environment))
-  end
-  let(:channel) { client.channel(channel_name) }
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
+      let(:client) do
+        Ably::Realtime::Client.new(default_options)
+      end
+      let(:channel) { client.channel(channel_name) }
 
-  let(:other_client) do
-    Ably::Realtime::Client.new(options.merge(api_key: api_key, environment: environment))
-  end
-  let(:other_client_channel) { other_client.channel(channel_name) }
+      let(:other_client) do
+        Ably::Realtime::Client.new(default_options)
+      end
+      let(:other_client_channel) { other_client.channel(channel_name) }
 
-  context 'using binary protocol' do
-    skip 'sends a string message'
-    skip 'sends a single message with an echo on another connection'
-    skip 'all tests with multiple messages'
-  end
+      let(:channel_name) { 'subscribe_send_text' }
+      let(:options) { { :protocol => :json } }
+      let(:payload) { 'Test message (subscribe_send_text)' }
 
-  context 'using text protocol' do
-    let(:channel_name) { 'subscribe_send_text' }
-    let(:options) { { :protocol => :json } }
-    let(:payload) { 'Test message (subscribe_send_text)' }
-
-    it 'sends a string message' do
-      run_reactor do
-        channel.attach
-        channel.on(:attached) do
-          channel.publish('test_event', payload) do |message|
-            expect(message.data).to eql(payload)
-            stop_reactor
+      it 'sends a string message' do
+        run_reactor do
+          channel.attach
+          channel.on(:attached) do
+            channel.publish('test_event', payload) do |message|
+              expect(message.data).to eql(payload)
+              stop_reactor
+            end
           end
         end
       end
-    end
 
-    it 'sends a single message with an echo on another connection' do
-      run_reactor do
-        other_client_channel.attach
-        other_client_channel.on(:attached) do
-          channel.publish 'test_event', payload
-          other_client_channel.subscribe('test_event') do |message|
-            expect(message.data).to eql(payload)
-            stop_reactor
+      it 'sends a single message with an echo on another connection' do
+        run_reactor do
+          other_client_channel.attach do
+            channel.publish 'test_event', payload
+            other_client_channel.subscribe('test_event') do |message|
+              expect(message.data).to eql(payload)
+              stop_reactor
+            end
           end
         end
       end
-    end
 
-    context 'with multiple messages' do
-      let(:send_count) { 15 }
-      let(:expected_echos) { send_count * 2 }
-      let(:channel_name) { SecureRandom.hex }
-      let(:echos) do
-        { client: 0, other: 0 }
-      end
-      let(:callbacks) do
-        { client: 0, other: 0 }
-      end
+      context 'with echo_messages => false' do
+        let(:no_echo_client) do
+          Ably::Realtime::Client.new(default_options.merge(echo_messages: false))
+        end
+        let(:no_echo_channel) { no_echo_client.channel(channel_name) }
+
+        it 'sends a single message without a reply yet the messages is echoed on another normal connection' do
+          run_reactor do
+            channel.attach do |echo_channel|
+              no_echo_channel.attach do
+                no_echo_channel.publish 'test_event', payload
+
+                no_echo_channel.subscribe('test_event') do |message|
+                  fail "Message should not have been echoed back"
+                end
 
-      def expect_messages_to_be_echoed_on_both_connections
-        {
-          channel              => :client,
-          other_client_channel => :other
-        }.each do |target_channel, echo_key|
-          EventMachine.defer do
-            target_channel.subscribe('test_event') do |message|
-              echos[echo_key] += 1
-
-              if echos[:client] == expected_echos && echos[:other] == expected_echos
-                # Wait briefly before doing the final check in case additional messages received
-                EventMachine.add_timer(0.5) do
-                  expect(echos[:client]).to eql(expected_echos)
-                  expect(echos[:other]).to eql(expected_echos)
-                  expect(callbacks[:client]).to eql(send_count)
-                  expect(callbacks[:other]).to eql(send_count)
-                  stop_reactor
+                echo_channel.subscribe('test_event') do |message|
+                  expect(message.data).to eql(payload)
+                  EventMachine.add_timer(1.5) { stop_reactor }
                 end
               end
             end
@@ -85,48 +71,84 @@ describe 'Ably::Realtime::Channel Messages' do
         end
       end
 
-      it 'sends and receives the messages on both opened connections (4 x send count due to local echos) and calls the callbacks' do
-        run_reactor(10) do
-          channel.attach
-          other_client_channel.attach
+      context 'with multiple messages' do
+        let(:send_count) { 15 }
+        let(:expected_echos) { send_count * 2 }
+        let(:channel_name) { SecureRandom.hex }
+        let(:echos) do
+          { client: 0, other: 0 }
+        end
+        let(:callbacks) do
+          { client: 0, other: 0 }
+        end
 
-          channel.on(:attached) do
-            other_client_channel.on(:attached) do
-              send_count.times do |index|
-                channel.publish('test_event', "#{index}: #{payload}") do
-                  callbacks[:client] += 1
+        def expect_messages_to_be_echoed_on_both_connections
+          {
+            channel              => :client,
+            other_client_channel => :other
+          }.each do |target_channel, echo_key|
+            EventMachine.defer do
+              target_channel.subscribe('test_event') do |message|
+                echos[echo_key] += 1
+
+                if echos[:client] == expected_echos && echos[:other] == expected_echos
+                  # Wait briefly before doing the final check in case additional messages received
+                  EventMachine.add_timer(0.5) do
+                    expect(echos[:client]).to eql(expected_echos)
+                    expect(echos[:other]).to eql(expected_echos)
+                    expect(callbacks[:client]).to eql(send_count)
+                    expect(callbacks[:other]).to eql(send_count)
+                    stop_reactor
+                  end
                 end
-                other_client_channel.publish('test_event', "#{index}: #{payload}") do
-                  callbacks[:other] += 1
+              end
+            end
+          end
+        end
+
+        it 'sends and receives the messages on both opened connections (4 x send count due to local echos) and calls the callbacks' do
+          run_reactor(10) do
+            channel.attach
+            other_client_channel.attach
+
+            channel.on(:attached) do
+              other_client_channel.on(:attached) do
+                send_count.times do |index|
+                  channel.publish('test_event', "#{index}: #{payload}") do
+                    callbacks[:client] += 1
+                  end
+                  other_client_channel.publish('test_event', "#{index}: #{payload}") do
+                    callbacks[:other] += 1
+                  end
                 end
+                expect_messages_to_be_echoed_on_both_connections
               end
-              expect_messages_to_be_echoed_on_both_connections
             end
           end
         end
       end
-    end
 
-    context 'without suitable publishing permissions' do
-      let(:restricted_client) do
-        Ably::Realtime::Client.new(options.merge(api_key: restricted_api_key, environment: environment))
-      end
-      let(:restricted_channel) { restricted_client.channel(channel_name) }
-      let(:payload) { 'Test message without permission to publish' }
+      context 'without suitable publishing permissions' do
+        let(:restricted_client) do
+          Ably::Realtime::Client.new(options.merge(api_key: restricted_api_key, environment: environment, protocol: protocol))
+        end
+        let(:restricted_channel) { restricted_client.channel("cansubscribe:example") }
+        let(:payload) { 'Test message without permission to publish' }
 
-      it 'calls the error callback' do
-        run_reactor do
-          restricted_channel.attach
-          restricted_channel.on(:attached) do
-            deferrable = restricted_channel.publish('test_event', payload)
-            deferrable.errback do |message, error|
-              expect(message.data).to eql(payload)
-              expect(error.status).to eql(401)
-              stop_reactor
-            end
-            deferrable.callback do |message|
-              fail 'Success callback should not have been called'
-              stop_reactor
+        it 'calls the error callback' do
+          run_reactor do
+            restricted_channel.attach
+            restricted_channel.on(:attached) do
+              deferrable = restricted_channel.publish('test_event', payload)
+              deferrable.errback do |message, error|
+                expect(message.data).to eql(payload)
+                expect(error.status).to eql(401)
+                stop_reactor
+              end
+              deferrable.callback do |message|
+                fail 'Success callback should not have been called'
+                stop_reactor
+              end
             end
           end
         end