ably-rest 1.2.5 → 1.2.6

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

@@ -60,13 +60,13 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       unless expected_state == :left
-        it 'raise an exception if the channel is detached' do
+        it "presence #{method_name} : raise an exception if the channel is detached" do
           setup_test(method_name, args, options) do
             channel_client_one.attach do
               channel_client_one.transition_state_machine :detaching
               channel_client_one.once(:detached) do
                 presence_client_one.public_send(method_name, args).tap do |deferrable|
-                  deferrable.callback { raise 'Get should not succeed' }
+                  deferrable.callback { raise "presence #{method_name} should not succeed" }
                   deferrable.errback do |error|
                     expect(error).to be_a(Ably::Exceptions::InvalidState)
                     expect(error.message).to match(/Operation is not allowed when channel is in STATE.Detached/)
@@ -78,12 +78,12 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
 
-        it 'raise an exception if the channel becomes detached' do
+        it "presence #{method_name} : raise an exception if the channel becomes detached" do
           setup_test(method_name, args, options) do
             channel_client_one.attach do
               channel_client_one.transition_state_machine :detaching
               presence_client_one.public_send(method_name, args).tap do |deferrable|
-                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.callback { raise "presence #{method_name} should not succeed" }
                 deferrable.errback do |error|
                   expect(error).to be_a(Ably::Exceptions::InvalidState)
                   expect(error.message).to match(/Operation failed as channel transitioned to STATE.Detached/)
@@ -94,13 +94,13 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
 
-        it 'raise an exception if the channel is failed' do
+        it "presence #{method_name} : raise an exception if the channel is failed" do
           setup_test(method_name, args, options) do
             channel_client_one.attach do
               channel_client_one.transition_state_machine :failed
               expect(channel_client_one.state).to eq(:failed)
               presence_client_one.public_send(method_name, args).tap do |deferrable|
-                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.callback { raise "presence #{method_name} : Get should not succeed" }
                 deferrable.errback do |error|
                   expect(error).to be_a(Ably::Exceptions::InvalidState)
                   expect(error.message).to match(/Operation is not allowed when channel is in STATE.Failed/)
@@ -111,11 +111,11 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
 
-        it 'raise an exception if the channel becomes failed' do
+        it "presence #{method_name} : raise an exception if the channel becomes failed" do
           setup_test(method_name, args, options) do
             channel_client_one.attach do
               presence_client_one.public_send(method_name, args).tap do |deferrable|
-                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.callback { raise "presence #{method_name} : Get should not succeed" }
                 deferrable.errback do |error|
                   expect(error).to be_a(Ably::Exceptions::MessageDeliveryFailed)
                   stop_reactor
@@ -516,11 +516,11 @@ describe Ably::Realtime::Presence, :event_machine do
         stop_reactor
       end
 
-      it 'will emit an :in_sync event when synchronisation is complete' do
+      it 'will emit an :sync_complete event when synchronisation is complete' do
         presence_client_one.enter
         presence_client_two.enter
 
-        presence_anonymous_client.members.once(:in_sync) do
+        presence_anonymous_client.members.once(:sync_complete) do
           stop_reactor
         end
 
@@ -545,7 +545,7 @@ describe Ably::Realtime::Presence, :event_machine do
             entered += 1
             next unless entered == 2
 
-            presence_anonymous_client.members.once(:in_sync) do
+            presence_anonymous_client.members.once(:sync_complete) do
               expect(presence_anonymous_client.members.count).to eql(2)
               member_ids = presence_anonymous_client.members.map(&:member_key)
               expect(member_ids.count).to eql(2)
@@ -580,7 +580,6 @@ describe Ably::Realtime::Presence, :event_machine do
               action = Ably::Models::ProtocolMessage::ACTION.Presence
               presence_msg = Ably::Models::ProtocolMessage.new(
                 action: action,
-                connection_serial: 20,
                 channel: channel_name,
                 presence: presence_data,
                 timestamp: Time.now.to_i * 1000
@@ -633,7 +632,6 @@ describe Ably::Realtime::Presence, :event_machine do
                     action = Ably::Models::ProtocolMessage::ACTION.Presence
                     presence_msg = Ably::Models::ProtocolMessage.new(
                       action: action,
-                      connection_serial: anonymous_client.connection.serial + 1,
                       channel: channel_name,
                       presence: presence_data,
                       timestamp: Time.now.to_i * 1000
@@ -644,7 +642,6 @@ describe Ably::Realtime::Presence, :event_machine do
                     action = Ably::Models::ProtocolMessage::ACTION.Sync
                     sync_msg = Ably::Models::ProtocolMessage.new(
                       action: action,
-                      connection_serial: anonymous_client.connection.serial + 2,
                       channel: channel_name,
                       channel_serial: 'validserialprefix:', # with no part after the `:` this indicates the end to the SYNC
                       presence: [],
@@ -707,21 +704,29 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context '#sync_complete? and SYNC flags (#RTP1)' do
       context 'when attaching to a channel without any members present' do
-        xit 'sync_complete? is true, there is no presence flag, and the presence channel is considered synced immediately (#RTP1)' do
-          flag_checked = false
+        it 'sync_complete? is true, no members are received and the presence channel is synced (#RTP1)' do
+          sync_info_received = false
 
           anonymous_client.connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
             if protocol_message.action == :attached
-              flag_checked = true
-              expect(protocol_message.has_presence_flag?).to eql(false)
+              if protocol_message.has_presence_flag?
+                sync_info_received = false
+              else
+                sync_info_received = true
+              end
+            end
+            if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Sync
+              expect(protocol_message.presence).to be_empty
+              sync_info_received = true
             end
           end
 
           channel_anonymous_client.attach do
-            expect(channel_anonymous_client.presence).to be_sync_complete
-            EventMachine.next_tick do
-              expect(flag_checked).to eql(true)
-              stop_reactor
+            wait_until(lambda { channel_anonymous_client.presence.sync_complete? and sync_info_received}) do
+              channel_anonymous_client.presence.get do |members|
+                expect(members).to be_empty
+                stop_reactor
+              end
             end
           end
         end
@@ -851,7 +856,7 @@ describe Ably::Realtime::Presence, :event_machine do
                   # Hacky accessing a private method, but absent members are intentionally not exposed to any public APIs
                   expect(presence_anonymous_client.members.send(:absent_members).length).to eql(1)
 
-                  presence_anonymous_client.members.once(:in_sync) do
+                  presence_anonymous_client.members.once(:sync_complete) do
                     # Check that members count is exact indicating the members with LEAVE action after sync are removed
                     expect(presence_anonymous_client).to be_sync_complete
                     expect(presence_anonymous_client.members.length).to eql(enter_expected_count - 1)
@@ -1007,7 +1012,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
                       channel_anonymous_client.attach do
                         presence_anonymous_client.get(wait_for_sync: false) do |members|
-                          expect(presence_anonymous_client.members).to_not be_in_sync
+                          expect(presence_anonymous_client.members).to_not be_sync_complete
                           expect(members.count).to eql(0)
                           stop_reactor
                         end
@@ -1214,7 +1219,7 @@ describe Ably::Realtime::Presence, :event_machine do
               presence_client_one.subscribe(:enter) do
                 presence_client_one.unsubscribe :enter
                 EventMachine.add_timer(0.5) do
-                  expect(presence_client_one.members).to be_in_sync
+                  expect(presence_client_one.members).to be_sync_complete
                   expect(presence_client_one.members.send(:members).count).to eql(1)
                   presence_client_one.leave data
                 end
@@ -1592,14 +1597,16 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'fails if the connection is DETACHED (#RTP11b)' do
-        channel_client_one.attach do
-          channel_client_one.detach do
-            presence_client_one.get.tap do |deferrable|
-              deferrable.callback { raise 'Get should not succeed' }
-              deferrable.errback do |error|
-                expect(error).to be_a(Ably::Exceptions::InvalidState)
-                expect(error.message).to match(/Operation is not allowed when channel is in STATE.Detached/)
-                stop_reactor
+        client_one.connection.once :connected do
+          channel_client_one.attach do
+            channel_client_one.detach do
+              presence_client_one.get.tap do |deferrable|
+                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.errback do |error|
+                  expect(error).to be_a(Ably::Exceptions::InvalidState)
+                  expect(error.message).to match(/Operation is not allowed when channel is in STATE.Detached/)
+                  stop_reactor
+                end
               end
             end
           end
@@ -1815,29 +1822,31 @@ describe Ably::Realtime::Presence, :event_machine do
         let(:total_members)      { members_per_client * 2 }
 
         it 'returns a complete list of members on all clients' do
-          members_per_client.times do |indx|
-            presence_client_one.enter_client("client_1:#{indx}")
-            presence_client_two.enter_client("client_2:#{indx}")
-          end
+          wait_until(lambda { client_one.connection.state == :connected and client_two.connection.state == :connected }) do
+            presence_client_one.subscribe(:enter) do
+              clients_entered[:client_one] += 1
+            end
 
-          presence_client_one.subscribe(:enter) do
-            clients_entered[:client_one] += 1
-          end
+            presence_client_two.subscribe(:enter) do
+              clients_entered[:client_two] += 1
+            end
 
-          presence_client_two.subscribe(:enter) do
-            clients_entered[:client_two] += 1
-          end
+            members_per_client.times do |indx|
+              presence_client_one.enter_client("client_1:#{indx}")
+              presence_client_two.enter_client("client_2:#{indx}")
+            end
 
-          wait_until(lambda { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
-            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)
+            wait_until(lambda { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
+              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(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
+                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
+                  end
                 end
               end
             end
@@ -2243,7 +2252,6 @@ describe Ably::Realtime::Presence, :event_machine do
             action = Ably::Models::ProtocolMessage::ACTION.Sync
             sync_message = Ably::Models::ProtocolMessage.new(
               action: action,
-              connection_serial: 10,
               channel_serial: 'sequenceid:cursor',
               channel: channel_name,
               presence: presence_sync_1,
@@ -2253,7 +2261,6 @@ describe Ably::Realtime::Presence, :event_machine do
 
             sync_message = Ably::Models::ProtocolMessage.new(
               action: action,
-              connection_serial: 11,
               channel_serial: 'sequenceid:', # indicates SYNC is complete
               channel: channel_name,
               presence: presence_sync_2,
@@ -2294,7 +2301,6 @@ describe Ably::Realtime::Presence, :event_machine do
             action = Ably::Models::ProtocolMessage::ACTION.Sync
             sync_message = Ably::Models::ProtocolMessage.new(
               action: action,
-              connection_serial: 10,
               channel: channel_name,
               presence: presence_sync,
               timestamp: Time.now.to_i * 1000
@@ -2348,7 +2354,6 @@ describe Ably::Realtime::Presence, :event_machine do
                 action = Ably::Models::ProtocolMessage::ACTION.Sync
                 sync_message = Ably::Models::ProtocolMessage.new(
                   action: action,
-                  connection_serial: 10,
                   channel: channel_name,
                   presence: presence_sync_protocol_message,
                   timestamp: Time.now.to_i * 1000
@@ -2467,7 +2472,7 @@ describe Ably::Realtime::Presence, :event_machine do
                 end
 
                 leave_message = Ably::Models::PresenceMessage.new(
-                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'id' => "#{client_two.connection.id}:#{client_two.connection.send(:client_msg_serial)}:1",
                   'clientId' => presence_client_two.client_id,
                   'connectionId' => client_two.connection.id,
                   'timestamp' => as_since_epoch(Time.now),
@@ -2532,37 +2537,59 @@ describe Ably::Realtime::Presence, :event_machine do
             let(:member_data) { random_str }
 
             it 'immediately resends all local presence members (#RTP5c2, #RTP19a)' do
-              in_sync_confirmed_no_local_members = false
-              local_member_leave_event_fired = false
+              member_leave_event_fired = false
+              local_members_sent = false
+
+              presence_client_one.subscribe(:enter) do |entered_member|
+                expect(entered_member.action).to eq(Ably::Models::PresenceMessage::ACTION.Enter)
+                expect(entered_member.data).to eq(member_data)
+                expect(entered_member.client_id).to eq(client_one.auth.client_id)
+                expect(entered_member.id).to be_truthy
+                entered_member_id = entered_member.id
 
-              presence_client_one.enter(member_data)
-              presence_client_one.subscribe(:enter) do
                 presence_client_one.unsubscribe :enter
 
-                presence_client_one.subscribe(:leave) do |message|
-                  # The local member will leave the PresenceMap due to the ATTACHED without Presence
-                  local_member_leave_event_fired = true
+                expect(presence_client_one.members.length).to eql(1)
+                expect(presence_client_one.members.local_members.length).to eql(1)
+
+                # subscribe to outgoing messages to check for entered local members with id
+                client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :presence
+                    protocol_message.presence.each do |local_member|
+                      expect(local_member.id).to eq(entered_member_id)
+                      expect(local_member.action).to eq(Ably::Models::PresenceMessage::ACTION.Enter)
+                      expect(local_member.data).to eq(member_data)
+                      expect(local_member.client_id).to eq(client_one.auth.client_id)
+                      local_members_sent = true
+                    end
+                  end
                 end
 
-                # Local members re-entered automatically appear as updates due to the
-                # fabricated ATTACHED message sent and the members already being present
-                presence_client_one.subscribe(:update) do |message|
-                  expect(local_member_leave_event_fired).to be_truthy
+                presence_client_one.subscribe(:leave) do |message|
+                  # Member will leave the PresenceMap due to the ATTACHED without Presence
                   expect(message.data).to eq(member_data)
                   expect(message.client_id).to eq(client_one.auth.client_id)
-                  EventMachine.next_tick do
-                    expect(presence_client_one.members.length).to eql(1)
-                    expect(presence_client_one.members.local_members.length).to eql(1)
-                    expect(in_sync_confirmed_no_local_members).to be_truthy
-                    stop_reactor
-                  end
+                  member_leave_event_fired = true
+                end
+
+                # Shouldn't receive enter/update message when local_members are entered
+                # This is due to the fact that, when we enter local member we also send
+                # member id, and server automatically checks for duplicate id and doesn't
+                # send presenceEnter or presenceUpdate if id is found.
+                presence_client_one.subscribe(:enter, :update) do |message|
+                  raise { "client shouldn't receive update event for entered local members" }
                 end
 
-                presence_client_one.members.once(:in_sync) do
-                  # Immediately after SYNC (no sync actually occurred, but this event fires immediately after a channel SYNCs or is not expecting to SYNC)
+                presence_client_one.members.once(:sync_complete) do
                   expect(presence_client_one.members.length).to eql(0)
-                  expect(presence_client_one.members.local_members.length).to eql(0)
-                  in_sync_confirmed_no_local_members = true
+
+                  # Since, this is a client sent event, local_members are not cleared
+                  # local_members acts a source of truth for server and not vice versa
+                  expect(presence_client_one.members.local_members.length).to eql(1)
+
+                  wait_until(lambda { member_leave_event_fired and local_members_sent}) do
+                    stop_reactor
+                  end
                 end
 
                 # ATTACHED ProtocolMessage with no presence flag will clear the presence set immediately, #RTP19a
@@ -2572,6 +2599,8 @@ describe Ably::Realtime::Presence, :event_machine do
                   flags: 0 # no resume or presence flag
                 )
               end
+
+              presence_client_one.enter(member_data)
             end
           end
         end
@@ -2684,23 +2713,25 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'channel transitions to the DETACHED state' do
         it 'clears the PresenceMap and local member map copy and does not emit any presence events (#RTP5a)' do
-          presence_client_one.enter
-          presence_client_one.subscribe(:enter) do
-            presence_client_one.unsubscribe :enter
+          wait_until(lambda { client_one.connection.state == :connected and anonymous_client.connection.state == :connected }) do
+            presence_client_one.enter
+            presence_client_one.subscribe(:enter) do
+              presence_client_one.unsubscribe :enter
 
-            channel_anonymous_client.attach do
-              presence_anonymous_client.get do |members|
-                expect(members.count).to eq(1)
+              channel_anonymous_client.attach do
+                presence_anonymous_client.get do |members|
+                  expect(members.count).to eq(1)
 
-                presence_anonymous_client.subscribe { raise 'No presence events should be emitted' }
-                channel_anonymous_client.detach do
-                  expect(presence_anonymous_client.members.length).to eq(0)
-                  expect(channel_anonymous_client).to be_detached
+                  presence_anonymous_client.subscribe { raise 'No presence events should be emitted' }
+                  channel_anonymous_client.detach do
+                    expect(presence_anonymous_client.members.length).to eq(0)
+                    expect(channel_anonymous_client).to be_detached
 
-                  expect(presence_client_one.members.local_members.count).to eq(1)
-                  channel_client_one.detach do
-                    expect(presence_client_one.members.local_members.count).to eq(0)
-                    stop_reactor
+                    expect(presence_client_one.members.local_members.count).to eq(1)
+                    channel_client_one.detach do
+                      expect(presence_client_one.members.local_members.count).to eq(0)
+                      stop_reactor
+                    end
                   end
                 end
               end

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

@@ -191,7 +191,7 @@ describe Ably::Rest::Channel do
         let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { capability: capability }) }
 
         it 'raises a permission error when publishing' do
-          expect { channel.publish(name, data) }.to raise_error(Ably::Exceptions::UnauthorizedRequest, /not permitted/)
+          expect { channel.publish(name, data) }.to raise_error(Ably::Exceptions::UnauthorizedRequest, /40160/)
         end
       end
 
@@ -280,7 +280,7 @@ describe Ably::Rest::Channel do
 
             context 'with an invalid client_id in the message' do
               it 'succeeds in the client library but then fails when published to Ably' do
-                expect { channel.publish([name: 'event', client_id: 'invalid']) }.to raise_error Ably::Exceptions::InvalidRequest, /mismatched clientId/
+                expect { channel.publish([name: 'event', client_id: 'invalid']) }.to raise_error(Ably::Exceptions::InvalidRequest, /40012/)
               end
             end
 

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

@@ -1095,9 +1095,16 @@ describe Ably::Rest::Client do
           end
 
           it 'sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)' do
-            client.channels.get('foo').publish("event")
+            response = client.channels.get('foo').publish("event")
+            expect(response).to eql true
             expect(publish_message_stub).to have_been_requested
-            expect(Ably::PROTOCOL_VERSION).to eql('1.2')
+            if agent.nil?
+              expect(publish_message_stub.to_s).to include("'Ably-Agent'=>'#{Ably::AGENT}'")
+              expect(publish_message_stub.to_s).to include("'X-Ably-Version'=>'2'")
+            else
+              expect(publish_message_stub.to_s).to include("'Ably-Agent'=>'ably-ruby/1.1.1 ruby/3.1.1'")
+              expect(publish_message_stub.to_s).to include("'X-Ably-Version'=>'2'")
+            end
           end
         end
       end

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

@@ -204,20 +204,17 @@ describe Ably::Rest::Channel, 'messages' do
         end
       end
 
-      specify 'idempotent publishing is disabled by default with <= 1.1 (#TO3n)' do
-        stub_const 'Ably::PROTOCOL_VERSION', '1.0'
-        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
-        expect(client.idempotent_rest_publishing).to be_falsey
-        stub_const 'Ably::PROTOCOL_VERSION', '1.1'
-        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+      specify 'idempotent publishing is set as per clientOptions' do
+        # set idempotent_rest_publishing to false
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol, idempotent_rest_publishing: false)
         expect(client.idempotent_rest_publishing).to be_falsey
-      end
 
-      specify 'idempotent publishing is enabled by default with >= 1.2 (#TO3n)' do
-        stub_const 'Ably::PROTOCOL_VERSION', '1.2'
-        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+        # set idempotent_rest_publishing to true
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol, idempotent_rest_publishing: true)
         expect(client.idempotent_rest_publishing).to be_truthy
-        stub_const 'Ably::PROTOCOL_VERSION', '1.3'
+      end
+
+      specify 'idempotent publishing is enabled by default (#TO3n)' do
         client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
         expect(client.idempotent_rest_publishing).to be_truthy
       end

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

@@ -181,7 +181,7 @@ describe Ably::Rest::Push::Admin do
                 client_id: client_id,
                 push: {
                   recipient: {
-                    transport_type: 'gcm',
+                    transport_type: 'fcm',
                     registration_token: 'secret_token',
                   }
                 }
@@ -250,7 +250,7 @@ describe Ably::Rest::Push::Admin do
                 client_id: client_id,
                 push: {
                   recipient: {
-                    transport_type: 'gcm',
+                    transport_type: 'fcm',
                     registration_token: 'secret_token',
                   }
                 }
@@ -268,7 +268,7 @@ describe Ably::Rest::Push::Admin do
           expect(device).to be_a(Ably::Models::DeviceDetails)
           expect(device.platform).to eql('ios')
           expect(device.client_id).to eql(client_id)
-          expect(device.push.recipient.fetch(:transport_type)).to eql('gcm')
+          expect(device.push.recipient.fetch(:transport_type)).to eql('fcm')
         end
 
         it 'returns a DeviceDetails object if a DeviceDetails object is provided' do
@@ -276,7 +276,7 @@ describe Ably::Rest::Push::Admin do
           expect(device).to be_a(Ably::Models::DeviceDetails)
           expect(device.platform).to eql('ios')
           expect(device.client_id).to eql(client_id)
-          expect(device.push.recipient.fetch(:transport_type)).to eql('gcm')
+          expect(device.push.recipient.fetch(:transport_type)).to eql('fcm')
         end
 
         it 'raises a ResourceMissing exception if device ID does not exist' do
@@ -350,14 +350,14 @@ describe Ably::Rest::Push::Admin do
           expect(device_retrieved.push.recipient['foo_bar']).to eql('string')
         end
 
-        context 'with GCM target' do
+        context 'with FCM target' do
           let(:device_token) { random_str }
 
           it 'saves the associated DevicePushDetails' do
             subject.save(device_details.merge(
               push: {
                 recipient: {
-                  transport_type: 'gcm',
+                  transport_type: 'fcm',
                   registrationToken: device_token
                 }
               }
@@ -365,14 +365,15 @@ describe Ably::Rest::Push::Admin do
 
             device_retrieved = subject.get(device_details.fetch(:id))
 
-            expect(device_retrieved.push.recipient.fetch('transportType')).to eql('gcm')
+            expect(device_retrieved.push.recipient.fetch('transportType')).to eql('fcm')
             expect(device_retrieved.push.recipient[:registration_token]).to eql(device_token)
           end
         end
 
         context 'with web target' do
           let(:target_url) { 'http://foo.com/bar' }
-          let(:encryption_key) { random_str }
+          let(:p256dh) { random_str }
+          let(:auth) { random_str }
 
           it 'saves the associated DevicePushDetails' do
             subject.save(device_details.merge(
@@ -380,7 +381,10 @@ describe Ably::Rest::Push::Admin do
                 recipient: {
                   transport_type: 'web',
                   targetUrl: target_url,
-                  encryptionKey: encryption_key
+                  encryptionKey: {
+                    p256dh: p256dh,
+                    auth: auth
+                  }
                 }
               }
             ))
@@ -389,7 +393,8 @@ describe Ably::Rest::Push::Admin do
 
             expect(device_retrieved.push.recipient[:transport_type]).to eql('web')
             expect(device_retrieved.push.recipient['targetUrl']).to eql(target_url)
-            expect(device_retrieved.push.recipient['encryptionKey']).to eql(encryption_key)
+            expect(device_retrieved.push.recipient['encryptionKey']['p256dh']).to eql(p256dh)
+            expect(device_retrieved.push.recipient['encryptionKey']['auth']).to eql(auth)
           end
         end
 
@@ -462,7 +467,7 @@ describe Ably::Rest::Push::Admin do
                 client_id: client_id,
                 push: {
                   recipient: {
-                    transport_type: 'gcm',
+                    transport_type: 'fcm',
                     registrationToken: 'secret_token',
                   }
                 }
@@ -476,7 +481,7 @@ describe Ably::Rest::Push::Admin do
                 client_id: client_id,
                 push: {
                   recipient: {
-                    transport_type: 'gcm',
+                    transport_type: 'fcm',
                     registration_token: 'secret_token',
                   }
                 }
@@ -525,7 +530,7 @@ describe Ably::Rest::Push::Admin do
                 client_id: client_id,
                 push: {
                   recipient: {
-                    transport_type: 'gcm',
+                    transport_type: 'fcm',
                     registration_token: 'secret_token',
                   }
                 }
@@ -539,7 +544,7 @@ describe Ably::Rest::Push::Admin do
                 client_id: client_id,
                 push: {
                   recipient: {
-                    transport_type: 'gcm',
+                    transport_type: 'fcm',
                     registration_token: 'secret_token',
                   }
                 }
@@ -580,7 +585,7 @@ describe Ably::Rest::Push::Admin do
           client_id: client_id,
           push: {
             recipient: {
-              transport_type: 'gcm',
+              transport_type: 'fcm',
               registration_token: 'secret_token',
             }
           }

data/lib/submodules/ably-ruby/spec/shared/client_initializer_behaviour.rb

@@ -130,7 +130,7 @@ shared_examples 'a client initializer' do
     end
 
     context 'with token' do
-      let(:client_options) { { token: 'token', auth_connect: false } }
+      let(:client_options) { { token: 'token', auto_connect: false } }
 
       it 'sets the token' do
         expect(subject.auth.current_token_details.token).to eql('token')

data/lib/submodules/ably-ruby/spec/support/markdown_spec_formatter.rb

@@ -83,7 +83,7 @@ module Ably
       attr_reader :output, :indent
 
       def documenting_rest_only?
-        File.exists?(File.expand_path('../../../../../../ably-rest.gemspec', __FILE__))
+        File.exist?(File.expand_path('../../../../../../ably-rest.gemspec', __FILE__))
       end
 
       def example_name_and_link(notification)