spec/acceptance/realtime/presence_spec.rb in ably-0.7.0 vs spec/acceptance/realtime/presence_spec.rb in ably-0.7.1

@@ -254,10 +254,20 @@
           expect(message.data).to eql(data_payload)
           stop_reactor
         end
       end
 
+      it 'updates the data to nil if :data argument is not provided (assumes nil value)' do
+        presence_client_one.enter(data: 'prior') do
+          presence_client_one.update
+        end
+        presence_client_one.subscribe(:update) do |message|
+          expect(message.data).to be_nil
+          stop_reactor
+        end
+      end
+
       it 'returns a Deferrable' do
         presence_client_one.enter do
           expect(presence_client_one.update).to be_a(EventMachine::Deferrable)
           stop_reactor
         end
@@ -275,14 +285,15 @@
     end
 
     context '#leave' do
       context ':data option' do
         let(:data) { random_str }
+        let(:enter_data) { random_str }
 
         context 'when set to a string' do
           it 'emits the new data for the leave event' do
-            presence_client_one.enter data: random_str do
+            presence_client_one.enter data: enter_data do
               presence_client_one.leave data: data
             end
 
             presence_client_one.subscribe(:leave) do |presence_message|
               expect(presence_message.data).to eql(data)
@@ -290,30 +301,30 @@
             end
           end
         end
 
         context 'when set to nil' do
-          it 'emits nil data for the leave event' do
-            presence_client_one.enter data: random_str do
+          it 'emits the previously defined value as a convenience' do
+            presence_client_one.enter data: enter_data do
               presence_client_one.leave data: nil
             end
 
             presence_client_one.subscribe(:leave) do |presence_message|
-              expect(presence_message.data).to be_nil
+              expect(presence_message.data).to eql(enter_data)
               stop_reactor
             end
           end
         end
 
         context 'when not passed as an argument' do
-          it 'emits the original data for the leave event' do
-            presence_client_one.enter data: data do
+          it 'emits the previously defined value as a convenience' do
+            presence_client_one.enter data: enter_data do
               presence_client_one.leave
             end
 
             presence_client_one.subscribe(:leave) do |presence_message|
-              expect(presence_message.data).to eql(data)
+              expect(presence_message.data).to eql(enter_data)
               stop_reactor
             end
           end
         end
       end
@@ -378,11 +389,11 @@
             client_count.times do |client_id|
               presence_client_one.enter_client("client:#{client_id}") do
                 presence_client_one.on(:entered) { raise 'Should not have entered' }
                 next unless client_id == client_count - 1
 
-                EventMachine.add_timer(0.5) do
+                EventMachine.add_timer(1) do
                   expect(presence_client_one.state).to eq(:initialized)
                   stop_reactor
                 end
               end
             end
@@ -433,18 +444,30 @@
             presence_anonymous_client.subscribe(:update) do |presence|
               expect(presence.data).to eql(data)
               clients << presence
               next unless clients.count == 5
 
-              EventMachine.add_timer(0.5) do
+              wait_until(proc { updated_callback_count == 5 }) do
                 expect(clients.map(&:client_id).uniq.count).to eql(5)
                 expect(updated_callback_count).to eql(5)
                 stop_reactor
               end
             end
           end
 
+          it 'updates the data attribute to null for the member when :data option is not provided (assumed null)' do
+            presence_client_one.enter_client('client_1') do
+              presence_client_one.update_client('client_1')
+            end
+
+            presence_anonymous_client.subscribe(:update) do |presence|
+              expect(presence.client_id).to eql('client_1')
+              expect(presence.data).to be_nil
+              stop_reactor
+            end
+          end
+
           it 'enters if not already entered' do
             updated_callback_count = 0
 
             client_count.times do |client_id|
               presence_client_one.update_client("client:#{client_id}", data: data) do
@@ -455,11 +478,11 @@
             presence_anonymous_client.subscribe(:enter) do |presence|
               expect(presence.data).to eql(data)
               clients << presence
               next unless clients.count == 5
 
-              EventMachine.add_timer(0.5) do
+              wait_until(proc { updated_callback_count == 5 }) do
                 expect(clients.map(&:client_id).uniq.count).to eql(5)
                 expect(updated_callback_count).to eql(5)
                 stop_reactor
               end
             end
@@ -496,11 +519,11 @@
               presence_anonymous_client.subscribe(:leave) do |presence|
                 expect(presence.data).to eql(data)
                 clients << presence
                 next unless clients.count == 5
 
-                EventMachine.add_timer(0.5) do
+                wait_until(proc { left_callback_count == 5 }) do
                   expect(clients.map(&:client_id).uniq.count).to eql(5)
                   expect(left_callback_count).to eql(5)
                   stop_reactor
                 end
               end
@@ -518,11 +541,11 @@
               presence_anonymous_client.subscribe(:leave) do |presence|
                 expect(presence.data).to be_nil
                 clients << presence
                 next unless clients.count == 5
 
-                EventMachine.add_timer(1) do
+                wait_until(proc { left_callback_count == 5 }) do
                   expect(clients.map(&:client_id).uniq.count).to eql(5)
                   expect(left_callback_count).to eql(5)
                   stop_reactor
                 end
               end
@@ -541,24 +564,24 @@
               end
             end
           end
 
           context 'with a nil value in :data option' do
-            it 'emits the leave event with a nil value' do
+            it 'emits the leave event with the previous value as a convenience' do
               presence_client_one.enter_client("client:unique", data: data) do
                 presence_client_one.leave_client("client:unique", data: nil)
               end
 
               presence_client_one.subscribe(:leave) do |presence_message|
-                expect(presence_message.data).to be_nil
+                expect(presence_message.data).to eql(data)
                 stop_reactor
               end
             end
           end
 
           context 'with no :data option' do
-            it 'emits the leave event with the previous data value' do
+            it 'emits the leave event with the previous value as a convenience' do
               presence_client_one.enter_client("client:unique", data: data) do
                 presence_client_one.leave_client("client:unique")
               end
 
               presence_client_one.subscribe(:leave) do |presence_message|
@@ -610,11 +633,18 @@
           end
         end
       end
 
       it 'filters by connection_id option if provided' do
-        when_all(presence_client_one.enter, presence_client_two.enter, and_wait: 0.5) do
+        presence_client_one.enter do
+          presence_client_two.enter
+        end
+
+        presence_client_one.subscribe(:enter) do |presence_message|
+          # wait until the client_two enter event has been sent to client_one
+          next unless presence_message.client_id == client_two.client_id
+
           presence_client_one.get(connection_id: client_one.connection.id) do |members|
             expect(members.count).to eq(1)
             expect(members.first.connection_id).to eql(client_one.connection.id)
 
             presence_client_one.get(connection_id: client_two.connection.id) do |members|
@@ -625,11 +655,18 @@
           end
         end
       end
 
       it 'filters by client_id option if provided' do
-        when_all(presence_client_one.enter(client_id: 'one'), presence_client_two.enter(client_id: 'two')) do
+        presence_client_one.enter(client_id: 'one') do
+          presence_client_two.enter client_id: 'two'
+        end
+
+        presence_client_one.subscribe(:enter) do |presence_message|
+          # wait until the client_two enter event has been sent to client_one
+          next unless presence_message.client_id == 'two'
+
           presence_client_one.get(client_id: 'one') do |members|
             expect(members.count).to eq(1)
             expect(members.first.client_id).to eql('one')
             expect(members.first.connection_id).to eql(client_one.connection.id)
 
@@ -663,25 +700,40 @@
             end
           end
         end
       end
 
-      it 'returns both members on both simultaneously connected clients' do
-        when_all(presence_client_one.enter(data: data_payload), presence_client_two.enter) do
-          EventMachine.add_timer(0.5) do
-            presence_client_one.get do |client_one_members|
-              presence_client_two.get do |client_two_members|
-                expect(client_one_members.count).to eq(client_two_members.count)
+      context 'with lots of members on different clients' do
+        let(:members_per_client) { 10 }
+        let(:clients_entered)    { Hash.new { |hash, key| hash[key] = 0 } }
+        let(:total_members)      { members_per_client * 2 }
 
-                member_client_one = client_one_members.find { |presence| presence.client_id == client_one.client_id }
-                member_client_two = client_one_members.find { |presence| presence.client_id == client_two.client_id }
+        it 'returns a complete list of members on all clients' do
+          members_per_client.times do |index|
+            presence_client_one.enter_client("client_1:#{index}")
+            presence_client_two.enter_client("client_2:#{index}")
+          end
 
-                expect(member_client_one).to be_a(Ably::Models::PresenceMessage)
-                expect(member_client_one.data).to eql(data_payload)
-                expect(member_client_two).to be_a(Ably::Models::PresenceMessage)
+          presence_client_one.subscribe(:enter) do
+            clients_entered[:client_one] += 1
+          end
 
-                stop_reactor
+          presence_client_two.subscribe(:enter) do
+            clients_entered[:client_two] += 1
+          end
+
+          wait_until(proc { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
+            presence_anonymous_client.get 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|
+                  expect(client_one_members.count).to eq(total_members)
+                  expect(client_one_members.count).to eq(client_two_members.count)
+                  stop_reactor
+                end
               end
             end
           end
         end
       end
@@ -718,10 +770,10 @@
             presence_client_two.unsubscribe &subscribe_callback
 
             presence_client_one.enter
             presence_client_one.update
             presence_client_one.leave do
-              EventMachine.add_timer(0.5) do
+              EventMachine.add_timer(1) do
                 stop_reactor
               end
             end
           end
         end