ably-rest 1.0.5 → 1.1.3

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

@@ -77,7 +77,13 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
             limit.times do |index|
               expect(next_page.items[index].data).to eql("history#{index + limit}")
             end
-            expect(next_page).to be_last
+            if next_page.has_next?
+              next_page.next do |last|
+                expect(last.items.length).to eql(0)
+              end
+            else
+              expect(next_page).to be_last
+            end
 
             stop_reactor
           end
@@ -106,22 +112,26 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
       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
+          channel.attach 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
         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
+          channel.attach 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
@@ -133,18 +143,20 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
         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') }
+          channel.attach do
+            batches.times do |batch|
+              EventMachine.add_timer(batch.to_f / batches.to_f) do
+                messages_per_batch.times { |index| channel.publish('event') }
+              end
             end
-          end
 
-          channel.subscribe('event') do |message|
-            messages << message
-            if messages.count == batches * messages_per_batch
-              channel.history do |page|
-                expect(page.items.map(&:id).sort).to eql(messages.map(&:id).sort)
-                stop_reactor
+            channel.subscribe('event') do |message|
+              messages << message
+              if messages.count == batches * messages_per_batch
+                channel.history do |page|
+                  expect(page.items.map(&:id).sort).to eql(messages.map(&:id).sort)
+                  stop_reactor
+                end
               end
             end
           end

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

@@ -13,6 +13,9 @@ describe Ably::Realtime::Channel, :event_machine do
     let(:channel)      { client.channel(channel_name) }
     let(:messages)     { [] }
 
+    let(:sub_client)   { auto_close Ably::Realtime::Client.new(client_options) }
+    let(:sub_channel)  { sub_client.channel(channel_name) }
+
     def disconnect_transport
       connection.transport.unbind
     end
@@ -276,8 +279,7 @@ describe Ably::Realtime::Channel, :event_machine do
             key: restricted_api_key,
             log_level: :fatal,
             use_token_auth: true,
-            # TODO: Use wildcard / default when intersection issue resolved, realtime#780
-            default_token_params: { capability: { "canpublish:foo" => ["publish"] } }
+            default_token_params: { capability: { "canpublish:foo" => ["*"] } }
           )
         end
         let(:restricted_client) do
@@ -726,7 +728,7 @@ describe Ably::Realtime::Channel, :event_machine do
       let(:name)    { random_str }
       let(:data)    { random_str }
 
-      context 'when attached' do
+      context 'when channel is attached (#RTL6c1)' do
         it 'publishes messages' do
           channel.attach do
             3.times { channel.publish('event', payload) }
@@ -738,81 +740,173 @@ describe Ably::Realtime::Channel, :event_machine do
         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
+      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
+            sub_channel.subscribe do |message|
+              messages << message if message.name == 'event'
+              if messages.count == 3
+                EventMachine.add_timer(1) do
+                  expect(channel.state).to eq(:initialized)
+                  stop_reactor
+                end
+              end
+            end
+            3.times { channel.publish('event', random_str) }
           end
         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...-1].join(':') }
-            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(':').last }
-            expect(message_indexes).to include("0", "1", "2")
-            stop_reactor
+      context 'when channel is Attaching (#RTL6c1)' do
+        it 'publishes messages immediately (#RTL6c1)' do
+          sub_channel.attach do
+            channel.once(:attaching) do
+              outgoing_message_count = 0
+              client.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                if protocol_message.action == :message
+                  raise "Expected channel state to be attaching when publishing messages, not #{channel.state}" unless channel.attaching?
+                  outgoing_message_count += protocol_message.messages.count
+                end
+              end
+              sub_channel.subscribe do |message|
+                messages << message if message.name == 'event'
+                if messages.count == 3
+                  expect(outgoing_message_count).to eql(3)
+                  stop_reactor
+                end
+              end
+              3.times { channel.publish('event', random_str) }
+            end
+            channel.attach
           end
         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 'fails the deferrable' do
-              expect(client.connection).to be_initialized
-              channel.publish('event').errback do |error|
-                expect(error).to be_a(Ably::Exceptions::MessageQueueingDisabled)
-                stop_reactor
+      context 'when channel is Detaching (#RTL6c1)' do
+        it 'publishes messages immediately (#RTL6c1)' do
+          sub_channel.attach do
+            channel.attach do
+              channel.once(:detaching) do
+                outgoing_message_count = 0
+                client.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :message
+                    raise "Expected channel state to be attaching when publishing messages, not #{channel.state}" unless channel.detaching?
+                    outgoing_message_count += protocol_message.messages.count
+                  end
+                end
+                sub_channel.subscribe do |message|
+                  messages << message if message.name == 'event'
+                  if messages.count == 3
+                    expect(outgoing_message_count).to eql(3)
+                    stop_reactor
+                  end
+                end
+                3.times { channel.publish('event', random_str) }
               end
+              channel.detach
             end
           end
+        end
+      end
 
-          context 'and connection state connecting' do
-            it 'fails the deferrable' do
-              client.connect
-              EventMachine.next_tick do
-                expect(client.connection).to be_connecting
-                channel.publish('event').errback do |error|
-                  expect(error).to be_a(Ably::Exceptions::MessageQueueingDisabled)
-                  stop_reactor
+      context 'when channel is Detached (#RTL6c1)' do
+        it 'publishes messages immediately (#RTL6c1)' do
+          sub_channel.attach do
+            channel.attach
+            channel.once(:attached) do
+              channel.once(:detached) do
+                outgoing_message_count = 0
+                client.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :message
+                    raise "Expected channel state to be attaching when publishing messages, not #{channel.state}" unless channel.detached?
+                    outgoing_message_count += protocol_message.messages.count
+                  end
+                end
+                sub_channel.subscribe do |message|
+                  messages << message if message.name == 'event'
+                  if messages.count == 3
+                    expect(outgoing_message_count).to eql(3)
+                    stop_reactor
+                  end
                 end
+                3.times { channel.publish('event', random_str) }
+              end
+              channel.detach
+            end
+          end
+        end
+      end
+
+      context 'with :queue_messages client option set to false (#RTL6c4)' do
+        let(:client_options)  { default_options.merge(queue_messages: false) }
+
+        context 'and connection state connected (#RTL6c4)' do
+          it 'publishes the message' do
+            client.connection.once(:connected) do
+              channel.publish('event')
+              stop_reactor
+            end
+          end
+        end
+
+        context 'and connection state initialized (#RTL6c4)' do
+          it 'fails the deferrable' do
+            expect(client.connection).to be_initialized
+            channel.publish('event').errback do |error|
+              expect(error).to be_a(Ably::Exceptions::MessageQueueingDisabled)
+              stop_reactor
+            end
+          end
+        end
+
+        context 'and connection state connecting (#RTL6c4)' do
+          it 'fails the deferrable' do
+            client.connect
+            EventMachine.next_tick do
+              expect(client.connection).to be_connecting
+              channel.publish('event').errback do |error|
+                expect(error).to be_a(Ably::Exceptions::MessageQueueingDisabled)
+                stop_reactor
               end
             end
           end
+        end
 
-          context 'and connection state disconnected' do
+        [:disconnected, :suspended, :closing, :closed].each do |invalid_connection_state|
+          context "and connection state #{invalid_connection_state} (#RTL6c4)" do
             let(:client_options)  { default_options.merge(queue_messages: false) }
             it 'fails the deferrable' do
               client.connection.once(:connected) do
-                client.connection.once(:disconnected) do
-                  expect(client.connection).to be_disconnected
+                client.connection.once(invalid_connection_state) do
+                  expect(client.connection.state).to eq(invalid_connection_state)
                   channel.publish('event').errback do |error|
                     expect(error).to be_a(Ably::Exceptions::MessageQueueingDisabled)
                     stop_reactor
                   end
                 end
-                client.connection.transition_state_machine :disconnected
+                if invalid_connection_state == :closed
+                  connection.close
+                else
+                  client.connection.transition_state_machine invalid_connection_state
+                end
               end
             end
           end
+        end
 
-          context 'and connection state connected' do
-            it 'publishes the message' do
-              client.connection.once(:connected) do
-                channel.publish('event')
-                stop_reactor
+        context 'and the channel state is failed (#RTL6c4)' do
+          let(:client_options)  { default_options.merge(queue_messages: false) }
+          it 'fails the deferrable' do
+            client.connection.once(:connected) do
+              channel.attach
+              channel.once(:attached) do
+                channel.once(:failed) do
+                  channel.publish('event').errback do |error|
+                    expect(error).to be_a(Ably::Exceptions::ChannelInactive)
+                    stop_reactor
+                  end
+                end
+                channel.transition_state_machine(:failed)
               end
             end
           end
@@ -914,9 +1008,6 @@ describe Ably::Realtime::Channel, :event_machine do
 
             it 'publishes the message without a name attribute in the payload' do
               published = false
-              channel.publish(nil, data) do
-                published = true
-              end
 
               channel.subscribe do |message|
                 expect(message.name).to be_nil
@@ -929,6 +1020,10 @@ describe Ably::Realtime::Channel, :event_machine do
                   end
                 end
               end
+
+              channel.publish(nil, data) do
+                published = true
+              end
             end
           end
 
@@ -937,9 +1032,6 @@ describe Ably::Realtime::Channel, :event_machine do
 
             it 'publishes the message without a data attribute in the payload' do
               published = false
-              channel.publish(name, nil) do
-                published = true
-              end
 
               channel.subscribe do |message|
                 expect(message.data).to be_nil
@@ -952,6 +1044,10 @@ describe Ably::Realtime::Channel, :event_machine do
                   end
                 end
               end
+
+              channel.publish(name, nil) do
+                published = true
+              end
             end
           end
 
@@ -1074,6 +1170,21 @@ describe Ably::Realtime::Channel, :event_machine do
         end
       end
 
+      context 'with more than allowed messages in a single publish' do
+        let(:channel_name) { random_str }
+
+        it 'rejects the publish' do
+          messages = (Ably::Realtime::Connection::MAX_PROTOCOL_MESSAGE_BATCH_SIZE + 1).times.map do
+            { name: 'foo' }
+          end
+
+          channel.publish(messages).errback do |error|
+            expect(error).to be_kind_of(Ably::Exceptions::InvalidRequest)
+            stop_reactor
+          end
+        end
+      end
+
       context 'identified clients' do
         context 'when authenticated with a wildcard client_id' do
           let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') }
@@ -1342,7 +1453,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'many times with different event names' do
         it 'filters events accordingly to each callback' do
-          click_callback = proc { |message| messages << message }
+          click_callback = lambda { |message| messages << message }
 
           channel.subscribe('click', &click_callback)
           channel.subscribe('move', &click_callback)
@@ -1887,6 +1998,8 @@ describe Ably::Realtime::Channel, :event_machine do
         end
 
         context '#resume (#RTL2f)' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+
           it 'is false when a channel first attaches' do
             channel.attach
             channel.on(:attached) do |channel_state_change|
@@ -1953,12 +2066,16 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       context 'moves to' do
-        %w(suspended detached failed).each do |channel_state|
+        %w(suspended failed).each do |channel_state|
           context(channel_state) do
+            let(:client) do
+              auto_close Ably::Realtime::Client.new(default_options.merge(log_level: :error))
+            end
+
             specify 'all queued messages fail with NACK (#RTL11)' do
               channel.attach do
                 # Move to disconnected
-                disconnect_transport_proc = Proc.new do
+                disconnect_transport_proc = lambda do
                   if connection.transport
                     connection.transport.close_connection_after_writing
                   else
@@ -1981,7 +2098,8 @@ describe Ably::Realtime::Channel, :event_machine do
             specify 'all published messages awaiting an ACK do nothing (#RTL11a)' do
               connection_been_disconnected = false
 
-              channel.attach do
+              channel.attach
+              channel.once(:attached) do
                 deferrable = channel.publish("foo")
                 deferrable.errback do |error|
                   fail "Message publish should not fail"
@@ -2090,7 +2208,7 @@ describe Ably::Realtime::Channel, :event_machine do
         it 'will move to the SUSPENDED state and then attempt to ATTACH with the ATTACHING state (#RTL13b)' do
           connection.once(:connected) do
             # Prevent any incoming or outgoing ATTACH/ATTACHED message from Ably
-            prevent_protocol_messages_proc = Proc.new do
+            prevent_protocol_messages_proc = lambda do
               if client.connection.transport
                 client.connection.transport.__incoming_protocol_msgbus__.unsubscribe
                 client.connection.transport.__outgoing_protocol_msgbus__.unsubscribe

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

@@ -12,6 +12,7 @@ describe Ably::Realtime::Client, :event_machine do
     let(:auth_params)    { subject.auth.auth_params_sync }
 
     subject              { auto_close Ably::Realtime::Client.new(client_options) }
+    let(:sub_client)     { auto_close Ably::Realtime::Client.new(client_options) }
 
     context 'initialization' do
       context 'basic auth' do
@@ -24,6 +25,22 @@ describe Ably::Realtime::Client, :event_machine do
           end
         end
 
+        context 'with an invalid API key' do
+          let(:custom_logger_object) { TestLogger.new }
+          let(:client) { Ably::Realtime::Client.new(client_options.merge(key: 'app.key:secret', logger: custom_logger_object)) }
+
+          it 'logs an entry with a help href url matching the code #TI5' do
+            client.connect
+            client.connection.once(:failed) do
+              expect(custom_logger_object.logs.find do |severity, message|
+                next unless %w(fatal error).include?(severity.to_s)
+                message.match(%r{https://help.ably.io/error/40400})
+              end).to_not be_nil
+              stop_reactor
+            end
+          end
+        end
+
         context ':tls option' do
           context 'set to false to force a plain-text connection' do
             let(:client_options) { default_options.merge(tls: false, log_level: :none) }
@@ -134,7 +151,7 @@ describe Ably::Realtime::Client, :event_machine do
 
           context 'with a wildcard client_id token' do
             subject                 { auto_close Ably::Realtime::Client.new(client_options) }
-            let(:client_options)    { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id) }
+            let(:client_options)    { default_options.merge(auth_callback: lambda { |token_params| auth_token_object }, client_id: client_id) }
             let(:rest_auth_client)  { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
             let(:auth_token_object) { rest_auth_client.auth.request_token(client_id: '*') }
 
@@ -155,7 +172,7 @@ describe Ably::Realtime::Client, :event_machine do
             end
 
             context 'and client_id omitted in ClientOptions' do
-              let(:client_options) { default_options.merge(auth_callback: Proc.new { auth_token_object }) }
+              let(:client_options) { default_options.merge(auth_callback: lambda { |token_params| auth_token_object }) }
 
               it 'uses the token provided clientId in the connection' do
                 connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
@@ -281,5 +298,141 @@ describe Ably::Realtime::Client, :event_machine do
         end
       end
     end
+
+    context '#publish (#TBC)' do
+      let(:channel_name) { random_str }
+      let(:channel)      { subject.channel(channel_name) }
+      let(:sub_channel)  { sub_client.channel(channel_name) }
+      let(:event_name)   { random_str }
+      let(:data)         { random_str }
+      let(:extras)       { { 'push' => { 'notification' => { 'title' => 'Testing' } } } }
+      let(:message)      { Ably::Models::Message.new(name: event_name, data: data) }
+
+      specify 'publishing a message implicity connects and publishes the message successfully on the provided channel' do
+        sub_channel.attach do
+          sub_channel.subscribe do |msg|
+            expect(msg.name).to eql(event_name)
+            expect(msg.data).to eql(data)
+            stop_reactor
+          end
+
+          subject.publish channel_name, event_name, data
+        end
+      end
+
+      specify 'publishing does not result in a channel being created' do
+        subject.publish channel_name, event_name, data
+        subject.channels.fetch(channel_name) do
+          # Block called if channel does not exist
+          EventMachine.add_timer(1) do
+            subject.channels.fetch(channel_name) do
+              # Block called if channel does not exist
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'with extras' do
+        let(:channel_name) { "pushenabled:#{random_str}" }
+
+        specify 'publishing supports extras' do
+          sub_channel.attach do
+            sub_channel.subscribe do |msg|
+              expect(msg.extras).to eql(extras)
+              stop_reactor
+            end
+
+            subject.publish channel_name, event_name, {}, extras: extras
+          end
+        end
+      end
+
+      specify 'publishing supports an array of Message objects' do
+        sub_channel.attach do
+          sub_channel.subscribe do |msg|
+            expect(msg.name).to eql(event_name)
+            expect(msg.data).to eql(data)
+            stop_reactor
+          end
+
+          subject.publish channel_name, [message]
+        end
+      end
+
+      specify 'publishing supports an array of Hash objects' do
+        sub_channel.attach do
+          sub_channel.subscribe do |msg|
+            expect(msg.name).to eql(event_name)
+            expect(msg.data).to eql(data)
+            stop_reactor
+          end
+
+          subject.publish channel_name, [name: event_name, data: data]
+        end
+      end
+
+      specify 'publishing on a closed connection fails' do
+        subject.connection.once(:connected) do
+          subject.connection.once(:closed) do
+            subject.publish(channel_name, name: event_name).errback do |error|
+              expect(error).to be_kind_of(Ably::Exceptions::MessageQueueingDisabled)
+              stop_reactor
+            end
+          end
+          connection.close
+        end
+      end
+
+      context 'queue_messages ClientOption' do
+        context 'when true' do
+          subject { auto_close Ably::Realtime::Client.new(client_options.merge(auto_connect: false)) }
+
+          it 'will queue messages whilst connecting and publish once connected' do
+            sub_channel.attach do
+              sub_channel.subscribe do |msg|
+                expect(msg.name).to eql(event_name)
+                stop_reactor
+              end
+              subject.connection.once(:connecting) do
+                subject.publish channel_name, event_name
+              end
+              subject.connection.connect
+            end
+          end
+        end
+
+        context 'when false' do
+          subject { auto_close Ably::Realtime::Client.new(client_options.merge(auto_connect: false, queue_messages: false)) }
+
+          it 'will reject messages on an initializing connection' do
+            sub_channel.attach do
+              subject.connection.once(:connecting) do
+                subject.publish(channel_name, event_name).errback do |error|
+                  expect(error).to be_kind_of(Ably::Exceptions::MessageQueueingDisabled)
+                  stop_reactor
+                end
+              end
+              subject.connection.connect
+            end
+          end
+        end
+      end
+
+      context 'with more than allowed messages in a single publish' do
+        let(:channel_name) { random_str }
+
+        it 'rejects the publish' do
+          messages = (Ably::Realtime::Connection::MAX_PROTOCOL_MESSAGE_BATCH_SIZE + 1).times.map do
+            { name: 'foo' }
+          end
+
+          subject.publish(channel_name, messages).errback do |error|
+            expect(error).to be_kind_of(Ably::Exceptions::InvalidRequest)
+            stop_reactor
+          end
+        end
+      end
+    end
   end
 end