ably-rest 0.8.1 → 0.8.2

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

@@ -53,6 +53,107 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      context 'with supported data payload content type' do
+        def register_presence_and_check_data(method_name, data)
+          if method_name.to_s.match(/_client/)
+            presence_client_one.public_send(method_name, 'client_id', data: data)
+          else
+            presence_client_one.public_send(method_name, data: data)
+          end
+
+          presence_client_one.subscribe do |presence_message|
+            expect(presence_message.data).to eql(data)
+            stop_reactor
+          end
+        end
+
+        context 'JSON Object (Hash)' do
+          let(:data) { { 'Hash' => 'true' } }
+
+          it 'is encoded and decoded to the same hash' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+
+        context 'JSON Array' do
+          let(:data) { [ nil, true, false, 55, 'string', { 'Hash' => true }, ['array'] ] }
+
+          it 'is encoded and decoded to the same Array' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+
+        context 'String' do
+          let(:data) { random_str }
+
+          it 'is encoded and decoded to the same Array' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+
+        context 'Binary' do
+          let(:data) { Base64.encode64(random_str) }
+
+          it 'is encoded and decoded to the same Array' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+      end
+
+      context 'with unsupported data payload content type' do
+        def presence_action(method_name, data)
+          if method_name.to_s.match(/_client/)
+            presence_client_one.public_send(method_name, 'client_id', data: data)
+          else
+            presence_client_one.public_send(method_name, data: data)
+          end
+        end
+
+        context 'Integer' do
+          let(:data) { 1 }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+
+        context 'Float' do
+          let(:data) { 1.1 }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+
+        context 'Boolean' do
+          let(:data) { true }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+
+        context 'False' do
+          let(:data) { false }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+      end
+
       it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         setup_test(method_name, args, options) do
           expect(presence_client_one.public_send(method_name, args)).to be_a(Ably::Util::SafeDeferrable)
@@ -153,13 +254,15 @@ describe Ably::Realtime::Presence, :event_machine do
         stop_reactor
       end
 
-      it 'will trigger an :in_sync event when synchronisation is complete' do
+      it 'will emit an :in_sync event when synchronisation is complete' do
         presence_client_one.enter
         presence_client_two.enter
 
         presence_anonymous_client.members.once(:in_sync) do
           stop_reactor
         end
+
+        channel_anonymous_client.attach
       end
 
       context 'before server sync complete' do
@@ -180,6 +283,8 @@ describe Ably::Realtime::Presence, :event_machine do
               expect(member_ids.uniq.count).to eql(2)
               stop_reactor
             end
+
+            channel_anonymous_client.attach
           end
         end
       end
@@ -200,7 +305,7 @@ describe Ably::Realtime::Presence, :event_machine do
           presence_client_one.enter do
             channel_anonymous_client.attach do
               expect(channel_anonymous_client.presence).to_not be_sync_complete
-              channel_anonymous_client.presence.get do
+              channel_anonymous_client.presence.get(wait_for_sync: true) do
                 expect(channel_anonymous_client.presence).to be_sync_complete
                 stop_reactor
               end
@@ -319,7 +424,7 @@ describe Ably::Realtime::Presence, :event_machine do
               end
             end
 
-            it 'does not emit :present after the :leave event has been emitted, and that member is not included in the list of members via #get' do
+            it 'does not emit :present after the :leave event has been emitted, and that member is not included in the list of members via #get with :wait_for_sync' do
               left_client = 10
               left_client_id = "client:#{left_client}"
 
@@ -341,7 +446,7 @@ describe Ably::Realtime::Presence, :event_machine do
                   member_left_emitted = true
                 end
 
-                presence_anonymous_client.get do |members|
+                presence_anonymous_client.get(wait_for_sync: true) do |members|
                   expect(members.count).to eql(enter_expected_count - 1)
                   expect(member_left_emitted).to eql(true)
                   expect(members.map(&:client_id)).to_not include(left_client_id)
@@ -365,43 +470,40 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           context '#get' do
-            it 'waits until sync is complete', event_machine: 15 do
-              enter_expected_count.times do |index|
-                presence_client_one.enter_client("client:#{index}") do |message|
-                  entered << message
-                  next unless entered.count == enter_expected_count
-
-                  presence_anonymous_client.get do |members|
-                    expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
-                    expect(members.count).to eql(enter_expected_count)
-                    stop_reactor
+            context 'with :wait_for_sync option set to true' do
+              it 'waits until sync is complete', event_machine: 15 do
+                enter_expected_count.times do |index|
+                  presence_client_one.enter_client("client:#{index}") do |message|
+                    entered << message
+                    next unless entered.count == enter_expected_count
+
+                    presence_anonymous_client.get(wait_for_sync: true) do |members|
+                      expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
+                      expect(members.count).to eql(enter_expected_count)
+                      stop_reactor
+                    end
                   end
                 end
               end
             end
-          end
-        end
-      end
-    end
 
-    context 'automatic attachment of channel on access to presence object' do
-      it 'is implicit if presence state is initialized' do
-        channel_client_one.presence
-        channel_client_one.on(:attached) do
-          expect(channel_client_one.state).to eq(:attached)
-          stop_reactor
-        end
-      end
-
-      it 'is disabled if presence state is not initialized' do
-        channel_client_one.attach do
-          channel_client_one.detach do
-            expect(channel_client_one.state).to eq(:detached)
-
-            channel_client_one.presence # access the presence object
-            EventMachine.add_timer(1) do
-              expect(channel_client_one.state).to eq(:detached)
-              stop_reactor
+            context 'by default' do
+              it 'it does not wait for sync', event_machine: 15 do
+                enter_expected_count.times do |index|
+                  presence_client_one.enter_client("client:#{index}") do |message|
+                    entered << message
+                    next unless entered.count == enter_expected_count
+
+                    channel_anonymous_client.attach do
+                      presence_anonymous_client.get do |members|
+                        expect(presence_anonymous_client.members).to_not be_in_sync
+                        expect(members.count).to eql(0)
+                        stop_reactor
+                      end
+                    end
+                  end
+                end
+              end
             end
           end
         end
@@ -571,7 +673,7 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         context 'when set to nil' do
-          it 'emits the previously defined value as a convenience' do
+          it 'emits a nil value for the data attribute when leaving' do
             presence_client_one.enter data: enter_data do
               presence_client_one.leave data: nil
             end
@@ -595,6 +697,22 @@ describe Ably::Realtime::Presence, :event_machine do
             end
           end
         end
+
+        context 'and sync is complete' do
+          it 'does not cache members that have left' do
+            presence_client_one.enter data: enter_data do
+              expect(presence_client_one.members).to be_in_sync
+              expect(presence_client_one.members.send(:members).count).to eql(1)
+              presence_client_one.leave data: data
+            end
+
+            presence_client_one.subscribe(:leave) do |presence_message|
+              expect(presence_message.data).to eql(data)
+              expect(presence_client_one.members.send(:members).count).to eql(0)
+              stop_reactor
+            end
+          end
+        end
       end
 
       it 'raises an exception if not entered' do
@@ -911,43 +1029,45 @@ describe Ably::Realtime::Presence, :event_machine do
                       )
         end
 
-        it 'fails if the connection fails' do
-          when_all(*connect_members_deferrables) do
-            channel_client_two.attach do
-              client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
-                if protocol_message.action == :sync
-                  sync_pages_received << protocol_message
-                  force_connection_failure client_two if sync_pages_received.count == 1
+        context 'when :wait_for_sync is true' do
+          it 'fails if the connection fails' do
+            when_all(*connect_members_deferrables) do
+              channel_client_two.attach do
+                client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :sync
+                    sync_pages_received << protocol_message
+                    force_connection_failure client_two if sync_pages_received.count == 1
+                  end
                 end
               end
-            end
 
-            presence_client_two.get.tap do |deferrable|
-              deferrable.callback { raise 'Get should not succeed' }
-              deferrable.errback do |error|
-                stop_reactor
+              presence_client_two.get(wait_for_sync: true).tap do |deferrable|
+                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.errback do |error|
+                  stop_reactor
+                end
               end
             end
           end
-        end
 
-        it 'fails if the channel is detached' do
-          when_all(*connect_members_deferrables) do
-            channel_client_two.attach do
-              client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
-                if protocol_message.action == :sync
-                  # prevent any more SYNC messages coming through
-                  client_two.connection.transport.__incoming_protocol_msgbus__.unsubscribe
-                  channel_client_two.change_state :detaching
-                  channel_client_two.change_state :detached
+          it 'fails if the channel is detached' do
+            when_all(*connect_members_deferrables) do
+              channel_client_two.attach do
+                client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :sync
+                    # prevent any more SYNC messages coming through
+                    client_two.connection.transport.__incoming_protocol_msgbus__.unsubscribe
+                    channel_client_two.change_state :detaching
+                    channel_client_two.change_state :detached
+                  end
                 end
               end
-            end
 
-            presence_client_two.get.tap do |deferrable|
-              deferrable.callback { raise 'Get should not succeed' }
-              deferrable.errback do |error|
-                stop_reactor
+              presence_client_two.get(wait_for_sync: true).tap do |deferrable|
+                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.errback do |error|
+                  stop_reactor
+                end
               end
             end
           end
@@ -1059,12 +1179,12 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           wait_until(proc { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
-            presence_anonymous_client.get do |anonymous_members|
+            presence_anonymous_client.get(wait_for_sync: true) do |anonymous_members|
               expect(anonymous_members.count).to eq(total_members)
               expect(anonymous_members.map(&:client_id).uniq.count).to eq(total_members)
 
-              presence_client_one.get do |client_one_members|
-                presence_client_two.get do |client_two_members|
+              presence_client_one.get(wait_for_sync: true) do |client_one_members|
+                presence_client_two.get(wait_for_sync: true) do |client_two_members|
                   expect(client_one_members.count).to eq(total_members)
                   expect(client_one_members.count).to eq(client_two_members.count)
                   stop_reactor
@@ -1319,7 +1439,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       specify 'expect :left event with client data from enter event' do
         presence_client_one.subscribe(:leave) do |message|
-          presence_client_one.get do |members|
+          presence_client_one.get(wait_for_sync: true) do |members|
             expect(members.count).to eq(0)
             expect(message.data).to eql(data_payload)
             stop_reactor
@@ -1335,8 +1455,7 @@ describe Ably::Realtime::Presence, :event_machine do
       let(:members_count) { 400 }
       let(:sync_pages_received) { [] }
 
-      # Will re-enable once https://github.com/ably/realtime/issues/91 is resolved
-      skip 'resumes the SYNC operation', em_timeout: 15 do
+      it 'resumes the SYNC operation', em_timeout: 15 do
         when_all(*members_count.times.map do |index|
           presence_client_one.enter_client("client:#{index}")
         end) do
@@ -1349,7 +1468,7 @@ describe Ably::Realtime::Presence, :event_machine do
             end
           end
 
-          presence_client_two.get do |members|
+          presence_client_two.get(wait_for_sync: true) do |members|
             expect(members.count).to eql(members_count)
             expect(members.map(&:member_key).uniq.count).to eql(members_count)
             stop_reactor

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

@@ -7,9 +7,9 @@ describe Ably::Realtime::Client, '#stats', :event_machine do
     end
 
     describe 'fetching stats' do
-      it 'should return a PaginatedResource' do
+      it 'should return a PaginatedResult' do
         client.stats do |stats|
-          expect(stats).to be_a(Ably::Models::PaginatedResource)
+          expect(stats).to be_a(Ably::Models::PaginatedResult)
           stop_reactor
         end
       end

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

@@ -64,7 +64,7 @@ describe Ably::Rest::Channel do
         end
       end
 
-      it 'should return paged history using the PaginatedResource model' do
+      it 'should return paged history using the PaginatedResult model' do
         page_1 = channel.history(limit: 1)
         page_2 = page_1.next
         page_3 = page_2.next

data/lib/submodules/ably-ruby/spec/acceptance/rest/encoders_spec.rb

@@ -162,7 +162,7 @@ describe Ably::Models::MessageEncoders do
       context 'with binary data' do
         let(:published_data) { binary_data }
 
-        it 'applies cipher and base64 encoding and sets the encoding attribute to "utf-8/cipher+aes-128-cbc/base64"' do
+        it 'applies cipher and base64 encoding and sets the encoding attribute to "cipher+aes-128-cbc/base64"' do
           on_publish do |encoding, encoded_data|
             expect(encoding).to eql('cipher+aes-128-cbc/base64')
             expect(decrypted(encoded_data, base64: true)).to eql(published_data)

data/lib/submodules/ably-ruby/spec/acceptance/rest/message_spec.rb

@@ -10,7 +10,7 @@ describe Ably::Rest::Channel, 'messages' do
     let(:client_options)         { default_client_options }
     let(:client)                 { Ably::Rest::Client.new(client_options) }
     let(:other_client)           { Ably::Rest::Client.new(client_options) }
-    let(:channel)                { client.channel('test') }
+    let(:channel)                { client.channel(random_str) }
 
     context 'publishing with an ASCII_8BIT message name' do
       let(:message_name) { random_str.encode(Encoding::ASCII_8BIT) }
@@ -23,6 +23,78 @@ describe Ably::Rest::Channel, 'messages' do
       end
     end
 
+    context 'with supported data payload content type' do
+      context 'JSON Object (Hash)' do
+        let(:data) { { 'Hash' => 'true' } }
+
+        it 'is encoded and decoded to the same hash' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+
+      context 'JSON Array' do
+        let(:data) { [ nil, true, false, 55, 'string', { 'Hash' => true }, ['array'] ] }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+
+      context 'String' do
+        let(:data) { random_str }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+
+      context 'Binary' do
+        let(:data) { Base64.encode64(random_str) }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+    end
+
+    context 'with unsupported data payload content type' do
+      context 'Integer' do
+        let(:data) { 1 }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        end
+      end
+
+      context 'Float' do
+        let(:data) { 1.1 }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        end
+      end
+
+      context 'Boolean' do
+        let(:data) { true }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        end
+      end
+
+      context 'False' do
+        let(:data) { false }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        end
+      end
+    end
+
     describe 'encryption and encoding' do
       let(:channel_name)      { "persisted:#{random_str}" }
       let(:cipher_options)    { { key: random_str(32) } }