ably 1.0.7 → 1.1.0

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -925,7 +925,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           last_message = nil
           channel = client.channels.get("foo")
 
-          connection.once(:connected) do
+          channel.attach do
             connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.action == :message
                 last_message = protocol_message

data/spec/acceptance/realtime/connection_spec.rb

@@ -1472,7 +1472,7 @@ describe Ably::Realtime::Connection, :event_machine do
           channel.attach do
             channel.once(:suspended) do
               channel.publish('test').errback do |error|
-                expect(error).to be_a(Ably::Exceptions::MessageQueueingDisabled)
+                expect(error).to be_a(Ably::Exceptions::ChannelInactive)
                 stop_reactor
               end
             end
@@ -1732,7 +1732,7 @@ describe Ably::Realtime::Connection, :event_machine do
       it 'sends the protocol version param v (#G4, #RTN2f)' do
         expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
           uri = URI.parse(url)
-          expect(CGI::parse(uri.query)['v'][0]).to eql('1.0')
+          expect(CGI::parse(uri.query)['v'][0]).to eql('1.1')
           stop_reactor
         end
         client
@@ -1741,7 +1741,7 @@ describe Ably::Realtime::Connection, :event_machine do
       it 'sends the lib version param lib (#RTN2g)' do
         expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
           uri = URI.parse(url)
-          expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-1\.0\.\d+(-[\w\.]+)?+$/)
+          expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-1\.1\.\d+(-[\w\.]+)?+$/)
           stop_reactor
         end
         client
@@ -1761,7 +1761,7 @@ describe Ably::Realtime::Connection, :event_machine do
         it 'sends the lib version param lib with the variant (#RTN2g + #RSC7b)' do
           expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
             uri = URI.parse(url)
-            expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-#{variant}-1\.0\.\d+(-[\w\.]+)?$/)
+            expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-#{variant}-1\.1\.\d+(-[\w\.]+)?$/)
             stop_reactor
           end
           client

data/spec/acceptance/realtime/message_spec.rb

@@ -116,7 +116,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Integer' do
         let(:data) { 1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -125,7 +125,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Float' do
         let(:data) { 1.1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -134,7 +134,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Boolean' do
         let(:data) { true }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -143,7 +143,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'False' do
         let(:data) { false }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -413,30 +413,32 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           let(:encrypted_channel) { client.channel(channel_name, cipher: cipher_options) }
 
           it 'encrypts message automatically before they are pushed to the server (#RTL7d)' do
-            encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
+            encrypted_channel.attach do
+              encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
 
-            encrypted_channel.__incoming_msgbus__.subscribe(:message) do |message|
-              if protocol == :json
-                expect(message['encoding']).to eql(encrypted_encoding)
-                expect(message['data']).to eql(encrypted_data)
-              else
-                # Messages received over binary protocol will not have Base64 encoded data
-                expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
-                expect(message['data']).to eql(encrypted_data_decoded)
+              encrypted_channel.__incoming_msgbus__.subscribe(:message) do |message|
+                if protocol == :json
+                  expect(message['encoding']).to eql(encrypted_encoding)
+                  expect(message['data']).to eql(encrypted_data)
+                else
+                  # Messages received over binary protocol will not have Base64 encoded data
+                  expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
+                  expect(message['data']).to eql(encrypted_data_decoded)
+                end
+                stop_reactor
               end
-              stop_reactor
-            end
 
-            encrypted_channel.publish 'example', encoded_data_decoded
+              encrypted_channel.publish 'example', encoded_data_decoded
+            end
           end
 
           it 'sends and receives messages that are encrypted & decrypted by the Ably library (#RTL7d)' do
-            encrypted_channel.publish 'example', encoded_data_decoded
             encrypted_channel.subscribe do |message|
               expect(message.data).to eql(encoded_data_decoded)
               expect(message.encoding).to be_nil
               stop_reactor
             end
+            encrypted_channel.publish 'example', encoded_data_decoded
           end
         end
       end

data/spec/acceptance/realtime/presence_spec.rb

@@ -256,7 +256,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Integer' do
           let(:data) { 1 }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -265,7 +265,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Float' do
           let(:data) { 1.1 }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -274,7 +274,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Boolean' do
           let(:data) { true }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -283,7 +283,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'False' do
           let(:data) { false }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -2299,7 +2299,7 @@ describe Ably::Realtime::Presence, :event_machine do
                   presence_events << [presence_message.client_id, presence_message.action.to_sym]
                   if presence_message.action == :leave
                     expect(presence_message.id).to be_nil
-                    expect(presence_message.timestamp.to_f * 1000).to be_within(20).of(Time.now.to_f * 1000)
+                    expect(presence_message.timestamp.to_f * 1000).to be_within(200).of(Time.now.to_f * 1000)
                   end
                 end
 

data/spec/acceptance/realtime/push_admin_spec.rb

@@ -0,0 +1,696 @@
+# encoding: utf-8
+require 'spec_helper'
+
+# These tests are a subset of Ably::Rest::Push::Admin in async EM style
+# The more robust complete test suite is in rest/push_admin_spec.rb
+describe Ably::Realtime::Push::Admin, :event_machine do
+  include Ably::Modules::Conversions
+
+  vary_by_protocol do
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:client_options)  { default_options }
+    let(:client) do
+      Ably::Realtime::Client.new(client_options)
+    end
+
+    let(:basic_notification_payload) do
+      {
+        notification: {
+          title: 'Test message',
+          body: 'Test message body'
+        }
+      }
+    end
+
+    let(:basic_recipient) do
+      {
+        transport_type: 'apns',
+        deviceToken: 'foo.bar'
+      }
+    end
+
+    describe '#publish' do
+      subject { client.push.admin }
+
+      it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
+        publish_deferrable = subject.publish(basic_recipient, basic_notification_payload)
+        expect(publish_deferrable).to be_a(Ably::Util::SafeDeferrable)
+        publish_deferrable.callback do
+          stop_reactor
+        end
+      end
+
+      context 'invalid arguments' do
+        it 'raises an exception with a nil recipient' do
+          expect { subject.publish(nil, {}) }.to raise_error ArgumentError, /Expecting a Hash/
+          stop_reactor
+        end
+
+        it 'raises an exception with a empty recipient' do
+          expect { subject.publish({}, {}) }.to raise_error ArgumentError, /empty/
+          stop_reactor
+        end
+
+        it 'raises an exception with a nil recipient' do
+          expect { subject.publish(basic_recipient, nil) }.to raise_error ArgumentError, /Expecting a Hash/
+          stop_reactor
+        end
+
+        it 'raises an exception with a empty recipient' do
+          expect { subject.publish(basic_recipient, {}) }.to raise_error ArgumentError, /empty/
+          stop_reactor
+        end
+      end
+
+      context 'invalid recipient' do
+        it 'raises an error after receiving a 40x realtime response' do
+          skip 'validation on raw push is not enabled in realtime'
+          subject.publish({ invalid_recipient_details: 'foo.bar' }, basic_notification_payload).errback do |error|
+            expect(error.message).to match(/Invalid recipient/)
+            stop_reactor
+          end
+        end
+      end
+
+      context 'invalid push data' do
+        it 'raises an error after receiving a 40x realtime response' do
+          skip 'validation on raw push is not enabled in realtime'
+          subject.publish(basic_recipient, { invalid_property_only: true }).errback do |error|
+            expect(error.message).to match(/Invalid push notification data/)
+            stop_reactor
+          end
+        end
+      end
+
+      context 'recipient variable case', webmock: true do
+        let(:recipient_payload) do
+          {
+            camel_case: {
+              second_level_camel_case: 'val'
+            }
+          }
+        end
+
+        let(:content_type) do
+          if protocol == :msgpack
+            'application/x-msgpack'
+          else
+            'application/json'
+          end
+        end
+
+        def request_body(request, protocol)
+          if protocol == :msgpack
+            MessagePack.unpack(request.body)
+          else
+            JSON.parse(request.body)
+          end
+        end
+
+        def serialize(object, protocol)
+          if protocol == :msgpack
+            MessagePack.pack(object)
+          else
+            JSON.dump(object)
+          end
+        end
+
+        let!(:publish_stub) do
+          stub_request(:post, "#{client.rest_client.endpoint}/push/publish").
+            with do |request|
+              expect(request_body(request, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
+              expect(request_body(request, protocol)['recipient']).to_not have_key('camel_case')
+              true
+            end.to_return(
+              :status => 201,
+              :body => serialize({}, protocol),
+              :headers => { 'Content-Type' => content_type }
+            )
+        end
+
+        it 'is converted to snakeCase' do
+          subject.publish(recipient_payload, basic_notification_payload) do
+            expect(publish_stub).to have_been_requested
+            stop_reactor
+          end
+        end
+      end
+
+      it 'accepts valid push data and recipient' do
+        subject.publish(basic_recipient, basic_notification_payload) do
+          stop_reactor
+        end
+      end
+
+      context 'using test environment channel recipient (#RSH1a)' do
+        let(:channel) { random_str }
+        let(:recipient) do
+          {
+            'transportType' => 'ablyChannel',
+            'channel' => channel,
+            'ablyKey' => api_key,
+            'ablyUrl' => client.rest_client.endpoint.to_s
+          }
+        end
+        let(:notification_payload) do
+          {
+            notification: {
+              title: random_str,
+            },
+            data: {
+              foo: random_str
+            }
+          }
+        end
+        let(:push_channel) do
+          client.channels.get(channel)
+        end
+
+        it 'triggers a push notification' do
+          push_channel.attach do
+            push_channel.subscribe do |message|
+              expect(message.name).to eql('__ably_push__')
+              expect(JSON.parse(message.data)['data']).to eql(JSON.parse(notification_payload[:data].to_json))
+              stop_reactor
+            end
+            subject.publish recipient, notification_payload
+          end
+        end
+      end
+    end
+
+    describe '#device_registrations' do
+      subject { client.push.admin.device_registrations }
+      let(:rest_device_registrations) {
+        client.rest_client.push.admin.device_registrations
+      }
+
+      context 'without permissions' do
+        let(:client_options) do
+          default_options.merge(
+            use_token_auth: true,
+            default_token_params: { capability: { :foo => ['subscribe'] } },
+            log_level: :fatal,
+          )
+        end
+
+        it 'raises a permissions not authorized exception' do
+          subject.get('does-not-exist').errback do |err|
+            expect(err).to be_a(Ably::Exceptions::UnauthorizedRequest)
+            subject.list.errback do |err|
+              expect(err).to be_a(Ably::Exceptions::UnauthorizedRequest)
+              subject.remove('does-not-exist').errback do |err|
+                expect(err).to be_a(Ably::Exceptions::UnauthorizedRequest)
+                subject.remove_where(device_id: 'does-not-exist').errback do |err|
+                  expect(err).to be_a(Ably::Exceptions::UnauthorizedRequest)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+
+      describe '#list' do
+        let(:client_id) { random_str }
+        let(:fixture_count) { 6 }
+
+        before do
+          fixture_count.times.map do |index|
+            Thread.new do # Parallelise the setup
+              rest_device_registrations.save({
+                                               id: "device-#{client_id}-#{index}",
+                                               platform: 'ios',
+                                               form_factor: 'phone',
+                                               client_id: client_id,
+                                               push: {
+                                                 recipient: {
+                                                   transport_type: 'gcm',
+                                                   registration_token: 'secret_token',
+                                                 }
+                                               }
+              })
+            end
+          end.each(&:join) # Wait for all threads to complete
+        end
+
+        after do
+          rest_device_registrations.remove_where client_id: client_id
+        end
+
+        it 'returns a PaginatedResult object containing DeviceDetails objects' do
+          subject.list do |page|
+            expect(page).to be_a(Ably::Models::PaginatedResult)
+            expect(page.items.first).to be_a(Ably::Models::DeviceDetails)
+            stop_reactor
+          end
+        end
+
+        it 'supports paging' do
+          subject.list(limit: 3, client_id: client_id) do |page|
+            expect(page).to be_a(Ably::Models::PaginatedResult)
+
+            expect(page.items.count).to eql(3)
+            page.next do |page|
+              expect(page.items.count).to eql(3)
+              page.next do |page|
+                expect(page.items.count).to eql(0)
+                expect(page).to be_last
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        it 'raises an exception if params are invalid' do
+          expect { subject.list("invalid_arg") }.to raise_error(ArgumentError)
+          stop_reactor
+        end
+      end
+
+      describe '#get' do
+        let(:fixture_count) { 2 }
+        let(:client_id) { random_str }
+
+        before do
+          fixture_count.times.map do |index|
+            Thread.new do # Parallelise the setup
+              rest_device_registrations.save({
+                                               id: "device-#{client_id}-#{index}",
+                                               platform: 'ios',
+                                               form_factor: 'phone',
+                                               client_id: client_id,
+                                               push: {
+                                                 recipient: {
+                                                   transport_type: 'gcm',
+                                                   registration_token: 'secret_token',
+                                                 }
+                                               }
+              })
+            end
+          end.each(&:join) # Wait for all threads to complete
+        end
+
+        after do
+          rest_device_registrations.remove_where client_id: client_id
+        end
+
+        it 'returns a DeviceDetails object if a device ID string is provided' do
+          subject.get("device-#{client_id}-0").callback do |device|
+            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')
+            stop_reactor
+          end
+        end
+
+        context 'with a failed request' do
+          let(:client_options) do
+            default_options.merge(
+              log_level: :fatal,
+            )
+          end
+
+          it 'raises a ResourceMissing exception if device ID does not exist' do
+            subject.get("device-does-not-exist").errback do |err|
+              expect(err).to be_a(Ably::Exceptions::ResourceMissing)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      describe '#save' do
+        let(:device_id) { random_str }
+        let(:client_id) { random_str }
+        let(:transport_token) { random_str }
+
+        let(:device_details) do
+          {
+            id: device_id,
+            platform: 'android',
+            form_factor: 'phone',
+            client_id: client_id,
+            metadata: {
+              foo: 'bar',
+              deep: {
+                val: true
+              }
+            },
+            push: {
+              recipient: {
+                transport_type: 'apns',
+                device_token: transport_token,
+                foo_bar: 'string',
+              },
+              error_reason: {
+                message: "this will be ignored"
+              },
+            }
+          }
+        end
+
+        after do
+          rest_device_registrations.remove_where client_id: client_id
+        end
+
+        it 'saves the new DeviceDetails Hash object' do
+          subject.save(device_details) do
+            subject.get(device_details.fetch(:id)) do |device_retrieved|
+              expect(device_retrieved).to be_a(Ably::Models::DeviceDetails)
+              expect(device_retrieved.id).to eql(device_id)
+              expect(device_retrieved.platform).to eql('android')
+              stop_reactor
+            end
+          end
+        end
+
+        context 'with a failed request' do
+          let(:client_options) do
+            default_options.merge(
+              log_level: :fatal,
+            )
+          end
+
+          it 'fails if data is invalid' do
+            subject.save(id: random_str, foo: 'bar').errback do |err|
+              expect(err).to be_a(Ably::Exceptions::InvalidRequest)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      describe '#remove_where' do
+        let(:device_id) { random_str }
+        let(:client_id) { random_str }
+
+        before do
+          rest_device_registrations.save({
+                                           id: "device-#{client_id}-0",
+                                           platform: 'ios',
+                                           form_factor: 'phone',
+                                           client_id: client_id,
+                                           push: {
+                                             recipient: {
+                                               transport_type: 'gcm',
+                                               registrationToken: 'secret_token',
+                                             }
+                                           }
+          })
+        end
+
+        after do
+          rest_device_registrations.remove_where client_id: client_id
+        end
+
+        it 'removes all matching device registrations by client_id' do
+          subject.remove_where(client_id: client_id, full_wait: true) do
+            subject.list do |page|
+              expect(page.items.count).to eql(0)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      describe '#remove' do
+        let(:device_id) { random_str }
+        let(:client_id) { random_str }
+
+        before do
+          rest_device_registrations.save({
+                                           id: "device-#{client_id}-0",
+                                           platform: 'ios',
+                                           form_factor: 'phone',
+                                           client_id: client_id,
+                                           push: {
+                                             recipient: {
+                                               transport_type: 'gcm',
+                                               registration_token: 'secret_token',
+                                             }
+                                           }
+          })
+        end
+
+        after do
+          rest_device_registrations.remove_where client_id: client_id
+        end
+
+        it 'removes the provided device id string' do
+          subject.remove("device-#{client_id}-0") do
+            subject.list do |page|
+              expect(page.items.count).to eql(0)
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
+
+    describe '#channel_subscriptions' do
+      let(:client_id) { random_str }
+      let(:device_id) { random_str }
+      let(:device_id_2) { random_str }
+      let(:default_device_attr) {
+        {
+          platform: 'ios',
+          form_factor: 'phone',
+          client_id: client_id,
+          push: {
+            recipient: {
+              transport_type: 'gcm',
+              registration_token: 'secret_token',
+            }
+          }
+        }
+      }
+
+      let(:rest_device_registrations) {
+        client.rest_client.push.admin.device_registrations
+      }
+
+      let(:rest_channel_subscriptions) {
+        client.rest_client.push.admin.channel_subscriptions
+      }
+
+      subject {
+        client.push.admin.channel_subscriptions
+      }
+
+      # Set up 2 devices with the same client_id
+      #  and two device with the unique device_id and no client_id
+      before do
+        [
+          lambda { rest_device_registrations.save(default_device_attr.merge(id: device_id)) },
+          lambda { rest_device_registrations.save(default_device_attr.merge(id: device_id_2)) },
+          lambda { rest_device_registrations.save(default_device_attr.merge(client_id: client_id, id: random_str)) },
+          lambda { rest_device_registrations.save(default_device_attr.merge(client_id: client_id, id: random_str)) }
+        ].map do |proc|
+          Thread.new { proc.call }
+        end.each(&:join) # Wait for all threads to complete
+      end
+
+      after do
+        rest_device_registrations.remove_where client_id: client_id
+        rest_device_registrations.remove_where device_id: device_id
+      end
+
+      describe '#list' do
+        let(:fixture_count) { 6 }
+
+        before do
+          fixture_count.times.map do |index|
+            Thread.new { rest_channel_subscriptions.save(channel: "pushenabled:#{random_str}", client_id: client_id) }
+          end + fixture_count.times.map do |index|
+            Thread.new { rest_channel_subscriptions.save(channel: "pushenabled:#{random_str}", device_id: device_id) }
+          end.each(&:join) # Wait for all threads to complete
+        end
+
+        it 'returns a PaginatedResult object containing DeviceDetails objects' do
+          subject.list(client_id: client_id) do |page|
+            expect(page).to be_a(Ably::Models::PaginatedResult)
+            expect(page.items.first).to be_a(Ably::Models::PushChannelSubscription)
+            stop_reactor
+          end
+        end
+
+        it 'supports paging' do
+          subject.list(limit: 3, device_id: device_id) do |page|
+            expect(page).to be_a(Ably::Models::PaginatedResult)
+
+            expect(page.items.count).to eql(3)
+            page.next do |page|
+              expect(page.items.count).to eql(3)
+              page.next do |page|
+                expect(page.items.count).to eql(0)
+                expect(page).to be_last
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        it 'raises an exception if none of the required filters are provided' do
+          expect { subject.list({ limit: 100 }) }.to raise_error(ArgumentError)
+          stop_reactor
+        end
+      end
+
+      describe '#list_channels' do
+        let(:fixture_count) { 6 }
+
+        before(:context) do
+          reload_test_app # TODO: Review if necessary later, currently other tests may affect list_channels
+        end
+
+        before do
+          fixture_count.times.map do |index|
+            Thread.new do
+              rest_channel_subscriptions.save(channel: "pushenabled:#{index}:#{random_str}", client_id: client_id)
+            end
+          end.each(&:join) # Wait for all threads to complete
+        end
+
+        after do
+          rest_channel_subscriptions.remove_where client_id: client_id, full_wait: true # undocumented arg to do deletes synchronously
+        end
+
+        it 'returns a PaginatedResult object containing String objects' do
+          subject.list_channels do |page|
+            expect(page).to be_a(Ably::Models::PaginatedResult)
+            expect(page.items.first).to be_a(String)
+            expect(page.items.length).to eql(fixture_count)
+            stop_reactor
+          end
+        end
+      end
+
+      describe '#save' do
+        let(:channel) { "pushenabled:#{random_str}" }
+        let(:client_id) { random_str }
+        let(:device_id) { random_str }
+
+        it 'saves the new client_id PushChannelSubscription Hash object' do
+          subject.save(channel: channel, client_id: client_id) do
+            subject.list(client_id: client_id) do |page|
+              channel_sub = page.items.first
+              expect(channel_sub).to be_a(Ably::Models::PushChannelSubscription)
+              expect(channel_sub.channel).to eql(channel)
+              stop_reactor
+            end
+          end
+        end
+
+        it 'raises an exception for invalid params' do
+          expect { subject.save(channel: '', client_id: '') }.to raise_error ArgumentError
+          expect { subject.save({}) }.to raise_error ArgumentError
+          stop_reactor
+        end
+
+        context 'failed requests' do
+          let(:client_options) do
+            default_options.merge(
+              log_level: :fatal,
+            )
+          end
+
+          it 'fails for invalid requests' do
+            subject.save(channel: 'not-enabled-channel', device_id: 'foo').errback do |err|
+              expect(err).to be_a(Ably::Exceptions::UnauthorizedRequest)
+              subject.save(channel: 'pushenabled:foo', device_id: 'not-registered-so-will-fail').errback do |err|
+                expect(err).to be_a(Ably::Exceptions::InvalidRequest)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      describe '#remove_where' do
+        let(:client_id) { random_str }
+        let(:device_id) { random_str }
+        let(:fixed_channel) { "pushenabled:#{random_str}" }
+
+        let(:fixture_count) { 6 }
+
+        before do
+          fixture_count.times.map do |index|
+            Thread.new do
+              rest_channel_subscriptions.save(channel: "pushenabled:#{random_str}", client_id: client_id)
+            end
+          end.each(&:join) # Wait for all threads to complete
+        end
+
+        it 'removes matching client_ids' do
+          subject.list(client_id: client_id) do |page|
+            expect(page.items.count).to eql(fixture_count)
+            subject.remove_where(client_id: client_id, full_wait: true) do
+              subject.list(client_id: client_id) do |page|
+                expect(page.items.count).to eql(0)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'failed requests' do
+          let(:client_options) do
+            default_options.merge(
+              log_level: :fatal,
+            )
+          end
+
+          it 'device_id and client_id filters in the same request are not supported' do
+            subject.remove_where(device_id: device_id, client_id: client_id).errback do |err|
+              expect(err).to be_a(Ably::Exceptions::InvalidRequest)
+              stop_reactor
+            end
+          end
+        end
+
+        it 'succeeds on no match' do
+          subject.remove_where(device_id: random_str, full_wait: true) do
+            subject.list(client_id: client_id) do |page|
+              expect(page.items.count).to eql(fixture_count)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      describe '#remove' do
+        let(:channel) { "pushenabled:#{random_str}" }
+        let(:channel2) { "pushenabled:#{random_str}" }
+        let(:client_id) { random_str }
+        let(:device_id) { random_str }
+
+        before do
+          rest_channel_subscriptions.save(channel: channel, client_id: client_id)
+        end
+
+        it 'removes match for Hash object by channel and client_id' do
+          subject.list(client_id: client_id) do |page|
+            expect(page.items.count).to eql(1)
+            subject.remove(channel: channel, client_id: client_id, full_wait: true) do
+              subject.list(client_id: client_id) do |page|
+                expect(page.items.count).to eql(0)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        it 'succeeds even if there is no match' do
+          subject.remove(device_id: 'does-not-exist', channel: random_str) do
+            subject.list(device_id: 'does-not-exist') do |page|
+              expect(page.items.count).to eql(0)
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
+  end
+end