ably-rest 0.8.2 → 0.8.3

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

@@ -264,7 +264,7 @@ describe Ably::Realtime::Channel, :event_machine 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
+            expect { channel.detach }.to raise_error Ably::Exceptions::InvalidStateChange
             stop_reactor
           end
         end
@@ -304,6 +304,24 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
       end
+
+      context 'when state is :initialized' do
+        it 'does nothing as there is no channel to detach' do
+          expect(channel).to be_initialized
+          channel.detach do
+            expect(channel).to be_initialized
+            stop_reactor
+          end
+        end
+
+        it 'returns a valid deferrable' do
+          expect(channel).to be_initialized
+          channel.detach.callback do
+            expect(channel).to be_initialized
+            stop_reactor
+          end
+        end
+      end
     end
 
     describe 'channel recovery in :attaching state' do
@@ -315,6 +333,9 @@ describe Ably::Realtime::Channel, :event_machine do
     end
 
     context '#publish' do
+      let(:name)    { random_str }
+      let(:data)    { random_str }
+
       context 'when attached' do
         it 'publishes messages' do
           channel.attach do
@@ -354,6 +375,197 @@ describe Ably::Realtime::Channel, :event_machine do
             stop_reactor
           end
         end
+
+        context 'with :queue_messages client option set to false' do
+          let(:client_options)  { default_options.merge(queue_messages: false) }
+
+          context 'and connection state initialized' do
+            it 'raises an exception' do
+              expect { channel.publish('event') }.to raise_error Ably::Exceptions::MessageQueueingDisabled
+              expect(client.connection).to be_initialized
+              stop_reactor
+            end
+          end
+
+          context 'and connection state connecting' do
+            it 'raises an exception' do
+              client.connect
+              EventMachine.next_tick do
+                expect { channel.publish('event') }.to raise_error Ably::Exceptions::MessageQueueingDisabled
+                expect(client.connection).to be_connecting
+                stop_reactor
+              end
+            end
+          end
+
+          context 'and connection state disconnected' do
+            let(:client_options)  { default_options.merge(queue_messages: false, :log_level => :error ) }
+            it 'raises an exception' do
+              client.connection.once(:connected) do
+                client.connection.once(:disconnected) do
+                  expect { channel.publish('event') }.to raise_error Ably::Exceptions::MessageQueueingDisabled
+                  expect(client.connection).to be_disconnected
+                  stop_reactor
+                end
+                client.connection.transition_state_machine :disconnected
+              end
+            end
+          end
+
+          context 'and connection state connected' do
+            it 'publishes the message' do
+              client.connection.once(:connected) do
+                channel.publish('event')
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      context 'with name and data arguments' do
+        it 'publishes the message and return true indicating success' do
+          channel.publish(name, data) do
+            channel.history do |page|
+              expect(page.items.first.name).to eql(name)
+              expect(page.items.first.data).to eql(data)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'with an array of Hash objects with :name and :data attributes' do
+        let(:messages) do
+          10.times.map do |index|
+            { name: index.to_s, data: { "index" => index + 10 } }
+          end
+        end
+
+        it 'publishes an array of messages in one ProtocolMessage' do
+          published = false
+
+          channel.attach do
+            client.connection.__outgoing_protocol_msgbus__.once(:protocol_message) do |protocol_message|
+              expect(protocol_message.messages.count).to eql(messages.count)
+              published = true
+            end
+
+            channel.publish(messages).callback do
+              channel.history do |page|
+                expect(page.items.map(&:name)).to match_array(messages.map { |message| message[:name] })
+                expect(page.items.map(&:data)).to match_array(messages.map { |message| message[:data] })
+                expect(published).to eql(true)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      context 'with an array of Message objects' do
+        let(:messages) do
+          10.times.map do |index|
+            Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+          end
+        end
+
+        it 'publishes an array of messages in one ProtocolMessage' do
+          published = false
+
+          channel.attach do
+            client.connection.__outgoing_protocol_msgbus__.once(:protocol_message) do |protocol_message|
+              expect(protocol_message.messages.count).to eql(messages.count)
+              published = true
+            end
+
+            channel.publish(messages).callback do
+              channel.history do |page|
+                expect(page.items.map(&:name)).to match_array(messages.map { |message| message[:name] })
+                expect(page.items.map(&:data)).to match_array(messages.map { |message| message[:data] })
+                expect(published).to eql(true)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with two invalid message out of 12' do
+          let(:client_options) { default_options.merge(client_id: 'valid') }
+          let(:invalid_messages) do
+            2.times.map do |index|
+              Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 }, client_id: 'prohibited')
+            end
+          end
+
+          it 'calls the errback once' do
+            skip 'Waiting for issue #256 to be resolved'
+            channel.publish(messages + invalid_messages).tap do |deferrable|
+              deferrable.callback do
+                raise 'Publish should have failed'
+              end
+
+              deferrable.errback do |error, message|
+                # TODO: Review whether we should fail once or multiple times
+                channel.history do |page|
+                  expect(page.items.count).to eql(0)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+
+        context 'only invalid messages' do
+          let(:client_options) { default_options.merge(client_id: 'valid') }
+          let(:invalid_messages) do
+            10.times.map do |index|
+              Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 }, client_id: 'prohibited')
+            end
+          end
+
+          it 'calls the errback once' do
+            skip 'Waiting for issue #256 to be resolved'
+            channel.publish(invalid_messages).tap do |deferrable|
+              deferrable.callback do
+                raise 'Publish should have failed'
+              end
+
+              deferrable.errback do |error, message|
+                channel.history do |page|
+                  expect(page.items.count).to eql(0)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context 'with many many messages and many connections simultaneously' do
+        let(:connection_count) { 5 }
+        let(:messages)         { 5.times.map { |index| { name: "test", data: "message-#{index}" } } }
+        let(:published)        { [] }
+        let(:channel_name)     { random_str }
+
+        it 'publishes all messages, all success callbacks are called, and a history request confirms all messages were published' do
+          connection_count.times.map do
+            Ably::Realtime::Client.new(client_options)
+          end.each do |client|
+            channel = client.channels.get(channel_name)
+            messages.each do |message|
+              channel.publish(message.fetch(:name), message.fetch(:data)) do
+                published << message
+                if published.count == connection_count * messages.count
+                  channel.history do |history_page|
+                    expect(history_page.items.count).to eql(connection_count * messages.count)
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+        end
       end
     end
 
@@ -368,6 +580,20 @@ describe Ably::Realtime::Channel, :event_machine do
         end
       end
 
+      context 'before attach' do
+        it 'receives messages as soon as attached' do
+          channel.subscribe('click') do |message|
+            expect(channel).to be_attached
+            expect(message.data).to eql('data')
+            stop_reactor
+          end
+
+          channel.publish('click', 'data')
+
+          expect(channel).to be_attaching
+        end
+      end
+
       context 'with no event argument' do
         it 'subscribes for all events' do
           channel.subscribe do |message|
@@ -430,7 +656,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
     context 'when connection state changes to' do
       context ':failed' do
-        let(:connection_error) { Ably::Exceptions::ConnectionError.new('forced failure', 500, 50000) }
+        let(:connection_error) { Ably::Exceptions::ConnectionFailed.new('forced failure', 500, 50000) }
         let(:client_options)   { default_options.merge(log_level: :none) }
 
         def fake_error(error)
@@ -441,7 +667,8 @@ describe Ably::Realtime::Channel, :event_machine do
           it 'transitions state to :failed' do
             channel.attach do
               channel.on(:failed) do |error|
-                expect(error).to eql(connection_error)
+                expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
+                expect(error.code).to eql(80002)
                 stop_reactor
               end
               fake_error connection_error
@@ -451,7 +678,8 @@ describe Ably::Realtime::Channel, :event_machine do
           it 'emits an error event on the channel' do
             channel.attach do
               channel.on(:error) do |error|
-                expect(error).to eql(connection_error)
+                expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
+                expect(error.code).to eql(80002)
                 stop_reactor
               end
               fake_error connection_error
@@ -461,7 +689,8 @@ describe Ably::Realtime::Channel, :event_machine do
           it 'updates the channel error_reason' do
             channel.attach do
               channel.on(:failed) do |error|
-                expect(channel.error_reason).to eql(connection_error)
+                expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
+                expect(error.code).to eql(80002)
                 stop_reactor
               end
               fake_error connection_error
@@ -509,6 +738,18 @@ describe Ably::Realtime::Channel, :event_machine do
             end
           end
         end
+
+        context 'a channel ATTACH request' do
+          it 'raises an exception' do
+            client.connect do
+              client.connection.once(:failed) do
+                expect { channel.attach }.to raise_error Ably::Exceptions::InvalidStateChange
+                stop_reactor
+              end
+              fake_error connection_error
+            end
+          end
+        end
       end
 
       context ':closed' do
@@ -564,6 +805,37 @@ describe Ably::Realtime::Channel, :event_machine do
             end
           end
         end
+
+        context 'a channel ATTACH request when connection CLOSED' do
+          it 'raises an exception' do
+            client.connect do
+              client.connection.once(:closed) do
+                expect { channel.attach }.to raise_error Ably::Exceptions::InvalidStateChange
+                stop_reactor
+              end
+              client.close
+            end
+          end
+        end
+
+        context 'a channel ATTACH request when connection CLOSING' do
+          it 'raises an exception' do
+            client.connect do
+              client.connection.once(:closing) do
+                expect { channel.attach }.to raise_error Ably::Exceptions::InvalidStateChange
+                stop_reactor
+              end
+              client.close
+            end
+          end
+        end
+      end
+    end
+
+    describe '#presence' do
+      it 'returns a Ably::Realtime::Presence object' do
+        expect(channel.presence).to be_a(Ably::Realtime::Presence)
+        stop_reactor
       end
     end
   end

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Realtime::Channels do
+  shared_examples 'a channel' do
+    it 'returns a channel object' do
+      expect(channel).to be_a Ably::Realtime::Channel
+      expect(channel.name).to eql(channel_name)
+    end
+
+    it 'returns channel object and passes the provided options' do
+      expect(channel_with_options.options).to eql(options)
+    end
+  end
+
+  vary_by_protocol do
+    let(:client) do
+      Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
+    end
+    let(:channel_name) { random_str }
+    let(:options)      { { key: 'value' } }
+
+    describe 'using shortcut method #channel on the client object' do
+      let(:channel) { client.channel(channel_name) }
+      let(:channel_with_options) { client.channel(channel_name, options) }
+      it_behaves_like 'a channel'
+    end
+
+    describe 'using #get method on client#channels' do
+      let(:channel) { client.channels.get(channel_name) }
+      let(:channel_with_options) { client.channels.get(channel_name, options) }
+      it_behaves_like 'a channel'
+    end
+
+    describe 'accessing an existing channel object with different options' do
+      let(:new_channel_options) { { encrypted: true } }
+      let(:original_channel)    { client.channels.get(channel_name, options) }
+
+      it 'overrides the existing channel options and returns the channel object' do
+        expect(original_channel.options).to_not include(:encrypted)
+        new_channel = client.channels.get(channel_name, new_channel_options)
+        expect(new_channel).to be_a(Ably::Realtime::Channel)
+        expect(new_channel.options[:encrypted]).to eql(true)
+      end
+    end
+
+    describe 'accessing an existing channel object without specifying any channel options' do
+      let(:original_channel) { client.channels.get(channel_name, options) }
+
+      it 'returns the existing channel without modifying the channel options' do
+        expect(original_channel.options).to eql(options)
+        new_channel = client.channels.get(channel_name)
+        expect(new_channel).to be_a(Ably::Realtime::Channel)
+        expect(original_channel.options).to eql(options)
+      end
+    end
+
+    describe 'using undocumented array accessor [] method on client#channels' do
+      let(:channel) { client.channels[channel_name] }
+      let(:channel_with_options) { client.channels[channel_name, options] }
+      it_behaves_like 'a channel'
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ describe Ably::Realtime::Client, :event_machine do
 
     let(:client_options) { default_options }
     let(:connection)     { subject.connection }
-    let(:auth_params)    { subject.auth.auth_params }
+    let(:auth_params)    { subject.auth.auth_params_sync }
 
     subject              { Ably::Realtime::Client.new(client_options) }
 
@@ -25,14 +25,14 @@ describe Ably::Realtime::Client, :event_machine do
         end
 
         context ':tls option' do
-          context 'set to false to forec a plain-text connection' do
+          context 'set to false to force a plain-text connection' do
             let(:client_options) { default_options.merge(tls: false, log_level: :none) }
 
             it 'fails to connect because a private key cannot be sent over a non-secure connection' do
               connection.on(:connected) { raise 'Should not have connected' }
 
               connection.on(:failed) do |error|
-                expect(error).to be_a(Ably::Exceptions::InsecureRequestError)
+                expect(error).to be_a(Ably::Exceptions::InsecureRequest)
                 stop_reactor
               end
             end
@@ -44,7 +44,7 @@ describe Ably::Realtime::Client, :event_machine do
         [true, false].each do |tls_enabled|
           context "with TLS #{tls_enabled ? 'enabled' : 'disabled'}" do
             let(:capability)      { { :foo => ["publish"] } }
-            let(:token_details)   { Ably::Realtime::Client.new(default_options).auth.request_token(capability: capability) }
+            let(:token_details)   { Ably::Realtime::Client.new(default_options).auth.request_token_sync(capability: capability) }
             let(:client_options)  { default_options.merge(token: token_details.token) }
 
             context 'and a pre-generated Token provided with the :token option' do
@@ -95,7 +95,7 @@ describe Ably::Realtime::Client, :event_machine do
           subject do
             Ably::Realtime::Client.new(client_options.merge(auth_callback: Proc.new do
               @block_called = true
-              auth.create_token_request(client_id: client_id)
+              auth.create_token_request_sync(client_id: client_id)
             end))
           end
 
@@ -115,5 +115,26 @@ describe Ably::Realtime::Client, :event_machine do
         end
       end
     end
+
+    context '#connection' do
+      it 'provides access to the Connection object' do
+        expect(subject.connection).to be_a(Ably::Realtime::Connection)
+        stop_reactor
+      end
+    end
+
+    context '#channels' do
+      it 'provides access to the Channels collection object' do
+        expect(subject.channels).to be_a(Ably::Realtime::Channels)
+        stop_reactor
+      end
+    end
+
+    context '#auth' do
+      it 'provides access to the Realtime::Auth object' do
+        expect(subject.auth).to be_a(Ably::Realtime::Auth)
+        stop_reactor
+      end
+    end
   end
 end