ably-rest 0.8.14 → 0.8.15

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

@@ -615,16 +615,23 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
 
-      it 'is set to 0 when a message sent ACK is received' do
-        channel.publish('event', 'data') do
+      it 'is set to 0 when a message is received back' do
+        channel.publish('event', 'data')
+        channel.subscribe do
           expect(connection.serial).to eql(0)
           stop_reactor
         end
       end
 
-      it 'is set to 1 when the second message sent ACK is received' do
+      it 'is set to 1 when the second message is received' do
         channel.publish('event', 'data') do
-          channel.publish('event', 'data') do
+          channel.publish('event', 'data')
+        end
+
+        messages = []
+        channel.subscribe do |message|
+          messages << message
+          if messages.length == 2
             expect(connection.serial).to eql(1)
             stop_reactor
           end
@@ -884,11 +891,16 @@ describe Ably::Realtime::Connection, :event_machine do
             expect(connection.serial).to eql(expected_serial)
 
             channel.attach do
-              channel.publish('event', 'data') do
+              channel.publish('event', 'data')
+              channel.subscribe do
+                channel.unsubscribe
+
                 expected_serial += 1 # attach message received
                 expect(connection.serial).to eql(expected_serial)
 
-                channel.publish('event', 'data') do
+                channel.publish('event', 'data')
+                channel.subscribe do
+                  channel.unsubscribe
                   expected_serial += 1 # attach message received
                   expect(connection.serial).to eql(expected_serial)
 
@@ -1278,6 +1290,22 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     context 'connection state change' do
+      # See https://github.com/ably/ably-ruby/issues/103
+      it 'emits event to all and single subscribers' do
+        connected_emitted = []
+        block = Proc.new do |state_change|
+          if state_change.current == :connected
+            connected_emitted << state_change
+            EventMachine.add_timer(0.5) do
+              expect(connected_emitted.length).to eql(2)
+              stop_reactor
+            end
+          end
+        end
+        connection.on(&block)
+        connection.on(:connected, &block)
+      end
+
       it 'emits a ConnectionStateChange object' do
         connection.on(:connected) do |connection_state_change|
           expect(connection_state_change).to be_a(Ably::Models::ConnectionStateChange)
@@ -1286,6 +1314,14 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       context 'ConnectionStateChange object' do
+        def unbind
+          if connection.transport
+            connection.transport.unbind
+          else
+            EventMachine.add_timer(0.005) { unbind }
+          end
+        end
+
         it 'has current state' do
           connection.on(:connected) do |connection_state_change|
             expect(connection_state_change.current).to eq(:connected)
@@ -1349,7 +1385,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 expect(connection_state_change.retry_in).to eql(0)
                 stop_reactor
               end
-              EventMachine.add_timer(0.005) { connection.transport.unbind }
+              unbind
             end
           end
 
@@ -1370,7 +1406,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   expect(connection_state_change.retry_in).to be > 0
                   stop_reactor
                 end
-                EventMachine.add_timer(0.005) { connection.transport.unbind }
+                unbind
               end
               connection.transport.unbind
             end

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

@@ -42,9 +42,11 @@ describe Ably::Realtime::Presence, :event_machine do
 
       def setup_test(method_name, args, options)
         if options[:enter_first]
-          presence_client_one.public_send(method_name.to_s.gsub(/leave|update/, 'enter'), args) do
+          presence_client_one.subscribe do
+            presence_client_one.unsubscribe
             yield
           end
+          presence_client_one.public_send(method_name.to_s.gsub(/leave|update/, 'enter'), args)
         else
           yield
         end
@@ -468,7 +470,14 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'once server sync is complete' do
         it 'behaves like an Enumerable allowing direct access to current members' do
-          when_all(presence_client_one.enter, presence_client_two.enter) do
+          presence_client_one.enter
+          presence_client_two.enter
+
+          entered = 0
+          presence_client_one.subscribe(:enter) do
+            entered += 1
+            next unless entered == 2
+
             presence_anonymous_client.members.once(:in_sync) do
               expect(presence_anonymous_client.members.count).to eql(2)
               member_ids = presence_anonymous_client.members.map(&:member_key)
@@ -495,7 +504,10 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'when attaching to a channel with members present' do
         it 'is false and the presence channel will subsequently be synced' do
-          presence_client_one.enter do
+          presence_client_one.enter
+          presence_client_one.subscribe(:enter) do
+            presence_client_one.unsubscribe :enter
+
             channel_anonymous_client.attach do
               expect(channel_anonymous_client.presence).to_not be_sync_complete
               channel_anonymous_client.presence.get(wait_for_sync: true) do
@@ -680,16 +692,18 @@ describe Ably::Realtime::Presence, :event_machine do
               it 'waits until sync is complete', em_timeout: 30 do # allow for slow connections and lots of messages
                 enter_expected_count.times do |index|
                   EventMachine.add_timer(index / 10) do
-                    presence_client_one.enter_client("client:#{index}") do |message|
-                      entered << message
-                      next unless entered.count == enter_expected_count
+                    presence_client_one.enter_client("client:#{index}")
+                  end
+                end
 
-                      presence_anonymous_client.get(wait_for_sync: true) do |members|
-                        expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
-                        expect(members.count).to eql(enter_expected_count)
-                        stop_reactor
-                      end
-                    end
+                presence_client_one.subscribe(:enter) do |message|
+                  entered << message
+                  next unless entered.count == enter_expected_count
+
+                  presence_anonymous_client.get(wait_for_sync: true) do |members|
+                    expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
+                    expect(members.count).to eql(enter_expected_count)
+                    stop_reactor
                   end
                 end
               end
@@ -697,19 +711,21 @@ describe Ably::Realtime::Presence, :event_machine do
 
             context 'by default' do
               it 'it does not wait for sync', em_timeout: 30 do # allow for slow connections and lots of messages
-                enter_expected_count.times do |index|
-                  EventMachine.add_timer(index / 10) do
-                    presence_client_one.enter_client("client:#{index}") do |message|
-                      entered << message
-                      next unless entered.count == enter_expected_count
-
-                      channel_anonymous_client.attach do
-                        presence_anonymous_client.get do |members|
-                          expect(presence_anonymous_client.members).to_not be_in_sync
-                          expect(members.count).to eql(0)
-                          stop_reactor
-                        end
-                      end
+                enter_expected_count.times do |indx|
+                  EventMachine.add_timer(indx / 10) do
+                    presence_client_one.enter_client "client:#{indx}"
+                  end
+                end
+
+                presence_client_one.subscribe(:enter) do |message|
+                  entered << message
+                  next unless entered.count == enter_expected_count
+
+                  channel_anonymous_client.attach do
+                    presence_anonymous_client.get do |members|
+                      expect(presence_anonymous_client.members).to_not be_in_sync
+                      expect(members.count).to eql(0)
+                      stop_reactor
                     end
                   end
                 end
@@ -896,15 +912,25 @@ describe Ably::Realtime::Presence, :event_machine do
 
         context 'and sync is complete' do
           it 'does not cache members that have left' do
-            presence_client_one.enter enter_data do
+            enter_ack = false
+
+            presence_client_one.subscribe(:enter) do
+              presence_client_one.unsubscribe :enter
+
               expect(presence_client_one.members).to be_in_sync
               expect(presence_client_one.members.send(:members).count).to eql(1)
               presence_client_one.leave data
             end
 
+            presence_client_one.enter(enter_data) do
+              enter_ack = true
+            end
+
             presence_client_one.subscribe(:leave) do |presence_message|
+              presence_client_one.unsubscribe :leave
               expect(presence_message.data).to eql(data)
               expect(presence_client_one.members.send(:members).count).to eql(0)
+              expect(enter_ack).to eql(true)
               stop_reactor
             end
           end
@@ -1290,7 +1316,9 @@ describe Ably::Realtime::Presence, :event_machine do
       # skip 'it fails if the connection changes to failed state'
 
       it 'returns the current members on the channel' do
-        presence_client_one.enter do
+        presence_client_one.enter
+        presence_client_one.subscribe(:enter) do
+          presence_client_one.unsubscribe :enter
           presence_client_one.get do |members|
             expect(members.count).to eq(1)
 
@@ -1351,7 +1379,10 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'does not wait for SYNC to complete if :wait_for_sync option is false' do
-        presence_client_one.enter do
+        presence_client_one.enter
+        presence_client_one.subscribe(:enter) do
+          presence_client_one.unsubscribe :enter
+
           presence_client_two.get(wait_for_sync: false) do |members|
             expect(members.count).to eql(0)
             stop_reactor
@@ -1362,11 +1393,13 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'when a member enters and then leaves' do
         it 'has no members' do
           presence_client_one.enter do
-            presence_client_one.leave do
-              presence_client_one.get do |members|
-                expect(members.count).to eq(0)
-                stop_reactor
-              end
+            presence_client_one.leave
+          end
+
+          presence_client_one.subscribe(:leave) do
+            presence_client_one.get do |members|
+              expect(members.count).to eq(0)
+              stop_reactor
             end
           end
         end
@@ -1524,7 +1557,10 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context 'REST #get' do
       it 'returns current members' do
-        presence_client_one.enter(data_payload) do
+        presence_client_one.enter data_payload
+        presence_client_one.subscribe(:enter) do
+          presence_client_one.unsubscribe :enter
+
           members_page = channel_rest_client_one.presence.get
           this_member = members_page.items.first
 
@@ -1538,7 +1574,10 @@ describe Ably::Realtime::Presence, :event_machine do
 
       it 'returns no members once left' do
         presence_client_one.enter(data_payload) do
-          presence_client_one.leave do
+          presence_client_one.leave
+          presence_client_one.subscribe(:leave) do
+            presence_client_one.unsubscribe :leave
+
             members_page = channel_rest_client_one.presence.get
             expect(members_page.items.count).to eql(0)
             stop_reactor
@@ -1654,7 +1693,8 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context '#get' do
         it 'returns a list of members with decrypted data' do
-          encrypted_channel.presence.enter(data) do
+          encrypted_channel.presence.enter(data)
+          encrypted_channel.presence.subscribe(:enter) do
             encrypted_channel.presence.get do |members|
               member = members.first
               expect(member.encoding).to be_nil
@@ -1667,7 +1707,8 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'REST #get' do
         it 'returns a list of members with decrypted data' do
-          encrypted_channel.presence.enter(data) do
+          encrypted_channel.presence.enter(data)
+          encrypted_channel.presence.subscribe(:enter) do
             member = channel_rest_client_one.presence.get.items.first
             expect(member.encoding).to be_nil
             expect(member.data).to eql(data)
@@ -1738,7 +1779,7 @@ describe Ably::Realtime::Presence, :event_machine do
     context 'connection failure mid-way through a large member sync' do
       let(:members_count) { 250 }
       let(:sync_pages_received) { [] }
-      let(:client_options)  { default_options.merge(log_level: :error) }
+      let(:client_options)  { default_options.merge(log_level: :fatal) }
 
       it 'resumes the SYNC operation', em_timeout: 15 do
         when_all(*members_count.times.map do |index|

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

@@ -360,10 +360,7 @@ describe Ably::Rest::Channel do
       let(:channel_name) { "persisted:#{random_str(4)}" }
       let(:channel) { client.channel(channel_name) }
       let(:endpoint) do
-        client.endpoint.tap do |client_end_point|
-          client_end_point.user = key_name
-          client_end_point.password = key_secret
-        end
+        client.endpoint
       end
       let(:default_history_options) do
           {
@@ -378,6 +375,7 @@ describe Ably::Rest::Channel do
             query_params = default_history_options
             .merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
             stub_request(:get, "#{endpoint}/channels/#{Addressable::URI.encode(channel_name)}/messages?#{query_params}").
+              with(basic_auth: [key_name, key_secret]).
               to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
           }
 

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

@@ -111,7 +111,8 @@ describe Ably::Rest::Client do
           let(:client_options)      { default_options.merge(key: api_key) }
 
           let!(:get_message_history_stub) do
-            stub_request(:get, "https://#{api_key}@#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}").
+            stub_request(:get, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}").
+              with(basic_auth: [key_name, key_secret]).
               to_return(body: [], headers: { 'Content-Type' => 'application/json' })
           end
 
@@ -284,7 +285,9 @@ describe Ably::Rest::Client do
       context 'when environment is NOT production' do
         let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key) }
         let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{api_key}@#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+          stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").
+            with(basic_auth: [key_name, key_secret]).
+            to_return do
             raise Faraday::TimeoutError.new('timeout error message')
           end
         end
@@ -313,16 +316,16 @@ describe Ably::Rest::Client do
         end
 
         let!(:first_fallback_request_stub) do
-          stub_request(:post, "https://#{api_key}@#{custom_hosts[0]}#{path}").to_return(&fallback_block)
+          stub_request(:post, "https://#{custom_hosts[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
         end
 
         let!(:second_fallback_request_stub) do
-          stub_request(:post, "https://#{api_key}@#{custom_hosts[1]}#{path}").to_return(&fallback_block)
+          stub_request(:post, "https://#{custom_hosts[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
         end
 
         context 'and connection times out' do
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
               raise Faraday::TimeoutError.new('timeout error message')
             end
           end
@@ -336,7 +339,7 @@ describe Ably::Rest::Client do
 
           context "and the total request time exeeds #{http_defaults.fetch(:max_retry_duration)} seconds" do
             let!(:default_host_request_stub) do
-              stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+              stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
                 sleep max_retry_duration * 1.5
                 raise Faraday::TimeoutError.new('timeout error message')
               end
@@ -353,7 +356,7 @@ describe Ably::Rest::Client do
 
         context 'and connection fails' do
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
               raise Faraday::ConnectionFailed.new('connection failure error message')
             end
           end
@@ -369,7 +372,7 @@ describe Ably::Rest::Client do
         context 'and basic authentication fails' do
           let(:status) { 401 }
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return(
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(
               headers: { 'Content-Type' => 'application/json' },
               status: status,
               body: {
@@ -401,7 +404,7 @@ describe Ably::Rest::Client do
             end
           end
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
           end
 
           it 'attempts the fallback hosts as this is an authentication failure' do
@@ -437,20 +440,20 @@ describe Ably::Rest::Client do
           end
         end
         let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
+          stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
         end
 
         context 'with custom fallback hosts provided' do
           let!(:first_fallback_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{custom_hosts[0]}#{path}").to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
           end
 
           let!(:second_fallback_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{custom_hosts[1]}#{path}").to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
           }
 
           it 'attempts the fallback hosts as this is an authentication failure (#RSC15b, #TO3k6)' do
@@ -516,7 +519,8 @@ describe Ably::Rest::Client do
                   port: port,
                   tls: false,
                   http_request_timeout: request_timeout,
-                  max_retry_duration: request_timeout * 3
+                  max_retry_duration: request_timeout * 3,
+                  log_level: :error
                 )
               end
               let(:fail_fallback_request_count) { 1 }
@@ -619,16 +623,16 @@ describe Ably::Rest::Client do
           end
         end
         let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{api_key}@#{env}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
+          stub_request(:post, "https://#{env}-#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
         end
 
         context 'with custom fallback hosts provided (#RSC15b, #TO3k6)' do
           let!(:first_fallback_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{custom_hosts[0]}#{path}").to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
           end
 
           let!(:second_fallback_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{custom_hosts[1]}#{path}").to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
           end
 
           let(:client_options) {
@@ -666,11 +670,11 @@ describe Ably::Rest::Client do
           }
 
           let!(:first_fallback_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{Ably::FALLBACK_HOSTS[0]}#{path}").to_return(&fallback_block)
+            stub_request(:post, "https://#{Ably::FALLBACK_HOSTS[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
           end
 
           let!(:second_fallback_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{Ably::FALLBACK_HOSTS[1]}#{path}").to_return(&fallback_block)
+            stub_request(:post, "https://#{Ably::FALLBACK_HOSTS[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
           end
 
           let(:client_options) {
@@ -701,7 +705,7 @@ describe Ably::Rest::Client do
           let(:path) { '/channels/test/publish' }
 
           let!(:custom_host_request_stub) do
-            stub_request(:post, "https://#{api_key}@#{custom_host}#{path}").to_return do
+            stub_request(:post, "https://#{custom_host}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
               raise Faraday::ConnectionFailed.new('connection failure error message')
             end
           end
@@ -840,11 +844,12 @@ describe Ably::Rest::Client do
             lib << Ably::VERSION
 
 
-            stub_request(:post, "#{client.endpoint.to_s.gsub('://', "://#{api_key}@")}/channels/foo/publish").
+            stub_request(:post, "#{client.endpoint.to_s.gsub('://', "://")}/channels/foo/publish").
               with(headers: {
                 'X-Ably-Version' => Ably::PROTOCOL_VERSION,
                 'X-Ably-Lib' => lib.join('-')
               }).
+              with(basic_auth: [key_name, key_secret]).
               to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
           end
 
@@ -855,5 +860,48 @@ describe Ably::Rest::Client do
         end
       end
     end
+
+    context '#request (#RSC19*)' do
+      let(:client_options) { default_options.merge(key: api_key) }
+
+      context 'get' do
+        it 'returns an HttpPaginatedResponse object' do
+          response = client.request(:get, 'time')
+          expect(response).to be_a(Ably::Models::HttpPaginatedResponse)
+          expect(response.status_code).to eql(200)
+        end
+
+        context '404 request to invalid URL' do
+          it 'returns an object with 404 status code and error message' do
+            response = client.request(:get, 'does-not-exist')
+            expect(response).to be_a(Ably::Models::HttpPaginatedResponse)
+            expect(response.error_message).to match(/Could not find/)
+            expect(response.error_code).to eql(40400)
+            expect(response.status_code).to eql(404)
+          end
+        end
+
+        context 'paged results' do
+          let(:channel_name) { random_str }
+
+          it 'provides paging' do
+            10.times do
+              client.request(:post, "/channels/#{channel_name}/publish", {}, { 'name': 'test' })
+            end
+            response = client.request(:get, "/channels/#{channel_name}/messages", { limit: 2 })
+            expect(response.items.length).to eql(2)
+            expect(response).to be_has_next
+            next_page = response.next
+            expect(next_page.items.length).to eql(2)
+            expect(next_page).to be_has_next
+            first_page_ids = response.items.map { |message| message['id'] }.uniq.sort
+            next_page_ids = next_page.items.map { |message| message['id'] }.uniq.sort
+            expect(first_page_ids).to_not eql(next_page_ids)
+            next_page = next_page.next
+            expect(next_page.items.length).to eql(2)
+          end
+        end
+      end
+    end
   end
 end