ably-rest 1.1.0 → 1.1.2.rc1

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

@@ -63,20 +63,22 @@ describe Ably::Realtime::Push::Admin, :event_machine do
       end
 
       context 'invalid recipient' do
+        let(:default_options) { { key: api_key, environment: environment, protocol: protocol, log_level: :fatal } }
+
         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/)
+            expect(error.message).to match(/recipient must contain/)
             stop_reactor
           end
         end
       end
 
       context 'invalid push data' do
+        let(:default_options) { { key: api_key, environment: environment, protocol: protocol, log_level: :fatal } }
+
         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/)
+            expect(error.message).to match(/Unexpected field/)
             stop_reactor
           end
         end
@@ -215,6 +217,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:client_id) { random_str }
         let(:fixture_count) { 6 }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             Thread.new do # Parallelise the setup
@@ -272,6 +280,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:fixture_count) { 2 }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             Thread.new do # Parallelise the setup
@@ -351,6 +365,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
           }
         end
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         after do
           rest_device_registrations.remove_where client_id: client_id
         end
@@ -386,6 +406,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:device_id) { random_str }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           rest_device_registrations.save({
                                            id: "device-#{client_id}-0",
@@ -419,6 +445,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:device_id) { random_str }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           rest_device_registrations.save({
                                            id: "device-#{client_id}-0",
@@ -479,6 +511,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         client.push.admin.channel_subscriptions
       }
 
+      before(:all) do
+        # As push tests often use the global scope (devices),
+        #   we need to ensure tests cannot conflict
+        reload_test_app
+      end
+
       # Set up 2 devices with the same client_id
       #  and two device with the unique device_id and no client_id
       before do
@@ -541,8 +579,10 @@ describe Ably::Realtime::Push::Admin, :event_machine do
       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
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
         end
 
         before do

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

@@ -275,6 +275,43 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'with a frozen message event name' do
+        let(:event_name) { random_str.freeze }
+
+        it 'succeeds and publishes with an implicit client_id' do
+          channel.publish([name: event_name])
+          channel.publish(event_name)
+
+          if !(RUBY_VERSION.match(/^1\./) || RUBY_VERSION.match(/^2\.[012]/))
+            channel.publish(+'foo-bar') # new style freeze, see https://github.com/ably/ably-ruby/issues/132
+          else
+            channel.publish('foo-bar'.freeze) # new + style not supported until Ruby 2.3
+          end
+
+          channel.history do |messages|
+            expect(messages.length).to eql(3)
+            expect(messages.first.name).to eql(event_name)
+            expect(messages[1].name).to eql(event_name)
+            expect(messages.last.name).to eql('foo-bar')
+          end
+        end
+      end
+
+      context 'with a frozen payload' do
+        let(:payload) { { foo: random_str.freeze }.freeze }
+
+        it 'succeeds and publishes with an implicit client_id' do
+          channel.publish([data: payload])
+          channel.publish(nil, payload)
+
+          channel.history do |messages|
+            expect(messages.length).to eql(2)
+            expect(messages.first.data).to eql(payload)
+            expect(messages.last.data).to eql(payload)
+          end
+        end
+      end
     end
 
     describe '#history' do

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

@@ -60,5 +60,11 @@ describe Ably::Rest::Channels do
       let(:channel_with_options) { client.channels[channel_name, options] }
       it_behaves_like 'a channel'
     end
+
+    describe 'using a frozen channel name' do
+      let(:channel) { client.channels[channel_name.freeze] }
+      let(:channel_with_options) { client.channels[channel_name.freeze, options] }
+      it_behaves_like 'a channel'
+    end
   end
 end

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

@@ -75,8 +75,7 @@ describe Ably::Rest::Channel, 'messages' do
       end
 
       context 'JSON Array' do
-        # TODO: Add nil type back in
-        let(:data) { { 'push' => { 'data' => { 'key' => [ true, false, 55, 'string', { 'Hash' => true }, ['array'] ] } } } }
+        let(:data) { { 'push' => { 'data' => { 'key' => [ true, false, 55, nil, 'string', { 'Hash' => true }, ['array'] ] } } } }
 
         it 'is encoded and decoded to the same deep multi-type object' do
           channel.publish 'event', {}, extras: data
@@ -120,8 +119,6 @@ describe Ably::Rest::Channel, 'messages' do
           let(:message) { Ably::Models::Message.new(id: id, data: data) }
 
           specify 'three REST publishes result in only one message being published' do
-            pending 'idempotency rolled out to global cluster'
-
             3.times { channel.publish [message] }
             expect(channel.history.items.length).to eql(1)
             expect(channel.history.items[0].id).to eql(id)
@@ -130,8 +127,6 @@ describe Ably::Rest::Channel, 'messages' do
 
         context 'with #publish arguments only' do
           it 'three REST publishes result in only one message being published' do
-            pending 'idempotency rolled out to global cluster'
-
             3.times { channel.publish 'event', data, id: id }
             expect(channel.history.items.length).to eql(1)
           end
@@ -143,8 +138,6 @@ describe Ably::Rest::Channel, 'messages' do
         end
 
         specify 'for multiple messages in one publish operation (#RSL1k3)' do
-          pending 'idempotency rolled out to global cluster'
-
           message_arr = 3.times.map { Ably::Models::Message.new(id: id, data: data) }
           expect { channel.publish message_arr }.to raise_error do |error|
             expect(error.code).to eql(40031) # Invalid publish request (invalid client-specified id), see https://github.com/ably/ably-common/pull/30
@@ -152,12 +145,10 @@ describe Ably::Rest::Channel, 'messages' do
         end
 
         specify 'for multiple messages in one publish operation with IDs following the required format described in RSL1k1 (#RSL1k3)' do
-          pending 'idempotency rolled out to global cluster'
-
           message_arr = 3.times.map { |index| Ably::Models::Message.new(id: "#{id}:#{index}", data: data) }
           channel.publish message_arr
-          expect(channel.history.items[0].id).to eql("{id}:0")
-          expect(channel.history.items[2].id).to eql("{id}:2")
+          expect(channel.history.items[2].id).to eql("#{id}:0")
+          expect(channel.history.items[0].id).to eql("#{id}:2")
           expect(channel.history.items.length).to eql(3)
         end
       end
@@ -174,7 +165,7 @@ describe Ably::Rest::Channel, 'messages' do
       end
 
       context 'when idempotent publishing is enabled in the client library ClientOptions (#TO3n)' do
-        let(:client_options) { default_client_options.merge(idempotent_rest_publishing: true, log_level: :error) }
+        let(:client_options) { default_client_options.merge(idempotent_rest_publishing: true, log_level: :error, fallback_hosts: ["#{environment}-realtime.ably.io"]) }
 
         context 'when there is a network failure triggering an automatic retry (#RSL1k4)' do
           def mock_for_two_publish_failures
@@ -195,8 +186,6 @@ describe Ably::Rest::Channel, 'messages' do
             before { mock_for_two_publish_failures }
 
             specify 'two REST publish retries result in only one message being published' do
-              pending 'idempotency rolled out to global cluster'
-
               channel.publish [message]
               expect(channel.history.items.length).to eql(1)
               expect(@failed_http_posts).to eql(2)
@@ -207,8 +196,6 @@ describe Ably::Rest::Channel, 'messages' do
             before { mock_for_two_publish_failures }
 
             specify 'two REST publish retries result in only one message being published' do
-              pending 'idempotency rolled out to global cluster'
-
               channel.publish 'event', data
               expect(channel.history.items.length).to eql(1)
               expect(@failed_http_posts).to eql(2)
@@ -221,8 +208,6 @@ describe Ably::Rest::Channel, 'messages' do
             before { mock_for_two_publish_failures }
 
             specify 'two REST publish retries result in only one message being published' do
-              pending 'idempotency rolled out to global cluster'
-
               channel.publish 'event', data, id: id
               expect(channel.history.items.length).to eql(1)
               expect(channel.history.items[0].id).to eql(id)
@@ -231,11 +216,9 @@ describe Ably::Rest::Channel, 'messages' do
           end
 
           specify 'for multiple messages in one publish operation' do
-            pending 'idempotency rolled out to global cluster'
-
             message_arr = 3.times.map { Ably::Models::Message.new(data: data) }
             3.times { channel.publish message_arr }
-            expect(channel.history.items.length).to eql(message_arr.length)
+            expect(channel.history.items.length).to eql(message_arr.length * 3)
           end
         end
 
@@ -248,13 +231,11 @@ describe Ably::Rest::Channel, 'messages' do
 
         context 'when publishing a batch of messages' do
           specify 'the ID is populated with a single random ID and sequence of serials from this lib (#RSL1k1)' do
-            pending 'idempotency rolled out to global cluster'
-
             message = { name: 'event' }
             channel.publish [message, message, message]
-            expect(channel.history.items[0].length).to eql(3)
-            expect(channel.history.items[0].id).to match(/^[A-Za-z0-9\+\/]+:0$/)
-            expect(channel.history.items[2].id).to match(/^[A-Za-z0-9\+\/]+:2$/)
+            expect(channel.history.items.length).to eql(3)
+            expect(channel.history.items[0].id).to match(/^[A-Za-z0-9\+\/]+:2$/)
+            expect(channel.history.items[2].id).to match(/^[A-Za-z0-9\+\/]+:0$/)
             base_64_id = channel.history.items[0].id.split(':')[0]
             expect(Base64.decode64(base_64_id).length).to eql(9)
           end

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

@@ -181,6 +181,12 @@ describe Ably::Rest::Push::Admin do
         let(:client_id) { random_str }
         let(:fixture_count) { 6 }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             Thread.new do
@@ -244,6 +250,12 @@ describe Ably::Rest::Push::Admin do
         let(:fixture_count) { 2 }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             Thread.new do
@@ -318,6 +330,12 @@ describe Ably::Rest::Push::Admin do
           }
         end
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         after do
           subject.remove_where client_id: client_id, full_wait: true
         end
@@ -444,6 +462,12 @@ describe Ably::Rest::Push::Admin do
         let(:device_id) { random_str }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           [
             Thread.new do
@@ -501,6 +525,12 @@ describe Ably::Rest::Push::Admin do
         let(:device_id) { random_str }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           [
             Thread.new do
@@ -585,8 +615,8 @@ describe Ably::Rest::Push::Admin do
       #  and two device with the unique device_id and no client_id
       before do
         [
-          lambda { device_registrations.save(default_device_attr.merge(id: device_id)) },
-          lambda { device_registrations.save(default_device_attr.merge(id: device_id_2)) },
+          lambda { device_registrations.save(default_device_attr.merge(id: device_id, client_id: nil)) },
+          lambda { device_registrations.save(default_device_attr.merge(id: device_id_2, client_id: nil)) },
           lambda { device_registrations.save(default_device_attr.merge(client_id: client_id, id: random_str)) },
           lambda { device_registrations.save(default_device_attr.merge(client_id: client_id, id: random_str)) }
         ].map do |proc|
@@ -602,6 +632,12 @@ describe Ably::Rest::Push::Admin do
       describe '#list (#RSH1c1)' do
         let(:fixture_count) { 6 }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             Thread.new { subject.save(channel: "pushenabled:#{random_str}", client_id: client_id) }
@@ -670,11 +706,14 @@ describe Ably::Rest::Push::Admin do
       describe '#list_channels (#RSH1c2)' do
         let(:fixture_count) { 6 }
 
-        before(:context) do
-          reload_test_app # TODO: Review if necessary late, currently other tests may affect list_channels
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
         end
 
         before do
+          # Create 6 channel subscriptions to the client ID for this test
           fixture_count.times.map do |index|
             Thread.new do
               subject.save(channel: "pushenabled:#{index}:#{random_str}", client_id: client_id)
@@ -694,9 +733,6 @@ describe Ably::Rest::Push::Admin do
         end
 
         it 'supports paging' do
-          skip 'Channel lists with limits is not reliable immediately after fixture creation'
-          # TODO: Remove this once list channels with limits is reliable immediately after fixtures created
-          #       See https://github.com/ably/realtime/issues/1882
           subject.list_channels
           page = subject.list_channels(limit: 3)
           expect(page).to be_a(Ably::Models::PaginatedResult)
@@ -730,6 +766,12 @@ describe Ably::Rest::Push::Admin do
         let(:client_id) { random_str }
         let(:device_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         it 'saves the new client_id PushChannelSubscription Hash object' do
           subject.save(channel: channel, client_id: client_id)
 
@@ -802,6 +844,12 @@ describe Ably::Rest::Push::Admin do
 
         let(:fixture_count) { 6 }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             [
@@ -814,8 +862,10 @@ describe Ably::Rest::Push::Admin do
           end.each(&:join) # Wait for all threads to complete
         end
 
+        # TODO: Reinstate once delete subscriptions by channel is possible
+        #       See https://github.com/ably/realtime/issues/1359
         it 'removes matching channels' do
-          skip 'Delete by channel is not yet supported'
+          skip 'deleting subscriptions is not yet supported realtime#1359'
           subject.remove_where channel: fixed_channel, full_wait: true
           expect(subject.list(channel: fixed_channel).items.count).to eql(0)
           expect(subject.list(client_id: client_id).items.count).to eql(0)
@@ -852,6 +902,12 @@ describe Ably::Rest::Push::Admin do
         let(:client_id) { random_str }
         let(:device_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           [
             lambda { subject.save(channel: channel, client_id: client_id) },

data/lib/submodules/ably-ruby/spec/spec_helper.rb

@@ -4,7 +4,7 @@ def console(message)
   puts "\033[31m[#{Time.now.strftime('%H:%M:%S.%L')}]\033[0m \033[33m#{message}\033[0m"
 end
 
-unless RUBY_VERSION.match(/^1/)
+unless RUBY_VERSION.match(/^1\./)
   require 'coveralls'
   Coveralls.wear!
 end