ably-rest 1.1.2 → 1.2.2

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

@@ -498,7 +498,9 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         presence_client_one.enter do
-          presence_client_one.leave
+          EventMachine.add_timer(0.5) do
+            presence_client_one.leave
+          end
         end
       end
     end
@@ -705,7 +707,7 @@ 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
-        it 'sync_complete? is true, there is no presence flag, and the presence channel is considered synced immediately (#RTP1)' do
+        xit 'sync_complete? is true, there is no presence flag, and the presence channel is considered synced immediately (#RTP1)' do
           flag_checked = false
 
           anonymous_client.connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
@@ -1211,10 +1213,11 @@ describe Ably::Realtime::Presence, :event_machine do
             channel_client_one.attach do
               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
+                EventMachine.add_timer(0.5) do
+                  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
               end
 
               presence_client_one.enter(enter_data) do
@@ -2137,16 +2140,18 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         it 'emits an error when cipher does not match and presence data cannot be decoded' do
-          incompatible_encrypted_channel.attach do
+          incompatible_encrypted_channel.once(:attached) do
             expect(client_two.logger).to receive(:error) do |*args, &block|
               expect(args.concat([block ? block.call : nil]).join(',')).to match(/Cipher algorithm AES-128-CBC does not match/)
               stop_reactor
-            end
+            end.at_least(:once)
 
             encrypted_channel.attach do
               encrypted_channel.presence.enter data
             end
           end
+
+          incompatible_encrypted_channel.attach
         end
       end
     end
@@ -2449,173 +2454,77 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
-      context 'when a channel becomes attached again' do
-        let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached.to_i }
-        let(:sync_action) { Ably::Models::ProtocolMessage::ACTION.Sync.to_i }
-        let(:presence_action) { Ably::Models::ProtocolMessage::ACTION.Presence.to_i }
-        let(:present_action) { Ably::Models::PresenceMessage::ACTION.Present.to_i }
-        let(:resume_flag) { 4 }
-        let(:presence_flag) { 1 }
-
-        def fabricate_incoming_protocol_message(protocol_message)
-          client_one.connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
-        end
-
-        # Prevents any messages from the WebSocket transport being sent / received
-        # Connection protocol message subscriptions are still active, but nothing reaches or comes from the WebSocket transport
-        def cripple_websocket_transport
-          client_one.connection.transport.__incoming_protocol_msgbus__.unsubscribe
-          client_one.connection.transport.__outgoing_protocol_msgbus__.unsubscribe
-        end
+      describe '#RTP17b' do
+        let(:leave_action) { Ably::Models::PresenceMessage::ACTION.Leave }
 
-        context 'and the resume flag is true' do
-          context 'and the presence flag is false' do
-            it 'does not send any presence events as the PresenceMap is in sync (#RTP5c1)' do
-              presence_client_one.enter
-              presence_client_one.subscribe(:enter) do
-                presence_client_one.unsubscribe :enter
-
-                client_one.connection.transport.__outgoing_protocol_msgbus__.subscribe do |message|
-                  raise "No presence state updates to Ably are expected. Message sent: #{message.to_json}" if client_one.connection.connected?
+        it 'updates presence members on leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to be_empty
+                  stop_reactor
                 end
 
-                cripple_websocket_transport
-
-                fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                  action: attached_action,
-                  channel: channel_name,
-                  flags: resume_flag
+                leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => client_two.connection.id,
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
                 )
 
-                EventMachine.add_timer(1) do
-                  presence_client_one.get do |members|
-                    expect(members.length).to eql(1)
-                    expect(presence_client_one.members.local_members.length).to eql(1)
-                    stop_reactor
-                  end
-                end
+                presence_client_two.__incoming_msgbus__.publish :presence, leave_message
               end
             end
           end
 
-          context 'and the presence flag is true' do
-            context 'and following the SYNC all local MemberMap members are present in the PresenceMap' do
-              it 'does nothing as MemberMap is in sync (#RTP5c2)' do
-                presence_client_one.enter
-                presence_client_one.subscribe(:enter) do
-                  presence_client_one.unsubscribe :enter
-
-                  expect(presence_client_one.members.length).to eql(1)
-                  expect(presence_client_one.members.local_members.length).to eql(1)
-
-                  presence_client_one.members.once(:in_sync) do
-                    presence_client_one.get do |members|
-                      expect(members.length).to eql(1)
-                      expect(presence_client_one.members.local_members.length).to eql(1)
-                      stop_reactor
-                    end
-                  end
-
-                  client_one.connection.transport.__outgoing_protocol_msgbus__.subscribe do |message|
-                    raise "No presence state updates to Ably are expected. Message sent: #{message.to_json}" if client_one.connection.connected?
-                  end
+          presence_client_two.enter
+        end
 
-                  cripple_websocket_transport
+        it 'does no update presence members on fabricated leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to_not be_empty
+                  stop_reactor
+                end
 
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: attached_action,
-                    channel: channel_name,
-                    flags: resume_flag + presence_flag
-                  )
+                fabricated_leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => "fabricated:#{presence_client_two.client_id}:0",
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
 
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: sync_action,
-                    channel: channel_name,
-                    presence: presence_client_one.members.map(&:shallow_clone).map(&:as_json),
-                    channelSerial: nil # no further SYNC messages expected
-                  )
-                end
+                presence_client_two.__incoming_msgbus__.publish :presence, fabricated_leave_message
               end
             end
+          end
 
-            context 'and following the SYNC a local MemberMap member is not present in the PresenceMap' do
-              it 're-enters the missing members automatically (#RTP5c2)' do
-                sync_check_completed = false
-
-                presence_client_one.enter
-                presence_client_one.subscribe(:enter) do
-                  presence_client_one.unsubscribe :enter
-
-                  expect(presence_client_one.members.length).to eql(1)
-                  expect(presence_client_one.members.local_members.length).to eql(1)
-
-                  client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |message|
-                    next if message.action == :close # ignore finalization of connection
-
-                    expect(message.action).to eq(:presence)
-                    presence_message = message.presence.first
-                    expect(presence_message.action).to eq(:enter)
-                    expect(presence_message.client_id).to eq(client_one.auth.client_id)
-
-                    presence_client_one.subscribe(:enter) do |message|
-                      expect(message.connection_id).to eql(client_one.connection.id)
-                      expect(message.client_id).to eq(client_one.auth.client_id)
-
-                      EventMachine.next_tick do
-                        expect(presence_client_one.members.length).to eql(2)
-                        expect(presence_client_one.members.local_members.length).to eql(1)
-                        expect(sync_check_completed).to be_truthy
-                        stop_reactor
-                      end
-                    end
-
-                    # Fabricate Ably sending back the Enter PresenceMessage to the client a short while after
-                    # ensuring the PresenceMap for a short period does not have this member as to be expected in reality
-                    EventMachine.add_timer(0.2) do
-                      connection_id = random_str
-                      fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                        action: presence_action,
-                        channel: channel_name,
-                        connectionId: client_one.connection.id,
-                        connectionSerial: 50,
-                        timestamp: as_since_epoch(Time.now),
-                        presence: [presence_message.shallow_clone(id: "#{client_one.connection.id}:0:0", timestamp: as_since_epoch(Time.now)).as_json]
-                      )
-                    end
-                  end
-
-                  presence_client_one.members.once(:in_sync) do
-                    # For a brief period, the client will have re-entered the missing members from the local_members
-                    # but the enter from Ably will have not been received, so at this point the local_members will be empty
-                    presence_client_one.get do |members|
-                      expect(members.length).to eql(1)
-                      expect(members.first.connection_id).to_not eql(client_one.connection.id)
-                      expect(presence_client_one.members.local_members.length).to eql(0)
-                      sync_check_completed = true
-                    end
-                  end
+          presence_client_two.enter
+        end
+      end
 
-                  cripple_websocket_transport
+      context 'when a channel becomes attached again' do
+        let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached.to_i }
+        let(:sync_action) { Ably::Models::ProtocolMessage::ACTION.Sync.to_i }
+        let(:presence_action) { Ably::Models::ProtocolMessage::ACTION.Presence.to_i }
+        let(:present_action) { Ably::Models::PresenceMessage::ACTION.Present.to_i }
+        let(:resume_flag) { 4 }
+        let(:presence_flag) { 1 }
 
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: attached_action,
-                    channel: channel_name,
-                    flags: resume_flag + presence_flag
-                  )
+        def fabricate_incoming_protocol_message(protocol_message)
+          client_one.connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
+        end
 
-                  # Complete the SYNC but without the member who was entered by this client
-                  connection_id = random_str
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: sync_action,
-                    channel: channel_name,
-                    timestamp: as_since_epoch(Time.now),
-                    presence: [{ id: "#{connection_id}:0:0", action: present_action, connection_id: connection_id, client_id: random_str }],
-                    chanenlSerial: nil # no further SYNC messages expected
-                  )
-                end
-              end
-            end
-          end
+        # Prevents any messages from the WebSocket transport being sent / received
+        # Connection protocol message subscriptions are still active, but nothing reaches or comes from the WebSocket transport
+        def cripple_websocket_transport
+          client_one.connection.transport.__incoming_protocol_msgbus__.unsubscribe
+          client_one.connection.transport.__outgoing_protocol_msgbus__.unsubscribe
         end
 
         context 'and the resume flag is false' do
@@ -2725,7 +2634,24 @@ describe Ably::Realtime::Presence, :event_machine do
       end
     end
 
-    context 'channel state side effects' do
+    context 'channel state side effects (RTP5)' do
+      context 'channel transitions to the ATTACHED state (RTP5b)' do
+        it 'all queued presence messages are sent' do
+          channel_client_one.on(:attached) do
+            client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+              if protocol_message.action == :presence
+                expect(protocol_message.action).to eq(:presence)
+                stop_reactor
+              end
+            end
+          end
+
+          presence_client_one.enter do
+            channel_client_one.attach
+          end
+        end
+      end
+
       context 'channel transitions to the FAILED state' do
         let(:anonymous_client) { auto_close Ably::Realtime::Client.new(client_options.merge(log_level: :fatal)) }
         let(:client_one)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: client_one_id, log_level: :fatal)) }

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

@@ -101,31 +101,15 @@ describe Ably::Realtime::Push::Admin, :event_machine do
           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')
+              expect(deserialize_body(request.body, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
+              expect(deserialize_body(request.body, protocol)['recipient']).to_not have_key('camel_case')
               true
             end.to_return(
               :status => 201,
-              :body => serialize({}, protocol),
+              :body => serialize_body({}, protocol),
               :headers => { 'Content-Type' => content_type }
             )
         end

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

@@ -41,22 +41,10 @@ describe Ably::Auth do
     end
 
     def request_body_includes(request, protocol, key, val)
-      body = if protocol == :msgpack
-        MessagePack.unpack(request.body)
-      else
-        JSON.parse(request.body)
-      end
+      body = deserialize_body(request.body, protocol)
       body[convert_to_mixed_case(key)].to_s == val.to_s
     end
 
-    def serialize(object, protocol)
-      if protocol == :msgpack
-        MessagePack.pack(object)
-      else
-        JSON.dump(object)
-      end
-    end
-
     it 'has immutable options' do
       expect { auth.options['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
     end
@@ -74,7 +62,7 @@ describe Ably::Auth do
 
       it 'creates a TokenRequest automatically and sends it to Ably to obtain a token', webmock: true do
         token_request_stub = stub_request(:post, "#{client.endpoint}/keys/#{key_name}/requestToken").
-          to_return(status: 201, body: serialize({}, protocol), headers: { 'Content-Type' => content_type })
+          to_return(status: 201, body: serialize_body({}, protocol), headers: { 'Content-Type' => content_type })
         expect(auth).to receive(:create_token_request).and_call_original
         auth.request_token
 
@@ -107,7 +95,7 @@ describe Ably::Auth do
                 request_body_includes(request, protocol, token_param, coerce_if_time_value(token_param, random, multiply: 1000))
               end.to_return(
                 :status => 201,
-                :body => serialize(token_response, protocol),
+                :body => serialize_body(token_response, protocol),
                 :headers => { 'Content-Type' => content_type }
               )
           end
@@ -138,7 +126,7 @@ describe Ably::Auth do
               request_body_includes(request, protocol, 'mac', mac)
             end.to_return(
               :status => 201,
-              :body => serialize(token_response, protocol),
+              :body => serialize_body(token_response, protocol),
               :headers => { 'Content-Type' => content_type })
         end
 
@@ -168,7 +156,7 @@ describe Ably::Auth do
               request_body_includes(request, protocol, 'mac', mac)
             end.to_return(
               :status => 201,
-              :body => serialize(token_response, protocol),
+              :body => serialize_body(token_response, protocol),
               :headers => { 'Content-Type' => content_type })
         end
 
@@ -310,7 +298,7 @@ describe Ably::Auth do
               request_body_includes(request, protocol, 'key_name', key_name)
             end.to_return(
               :status => 201,
-              :body => serialize(token_response, protocol),
+              :body => serialize_body(token_response, protocol),
               :headers => { 'Content-Type' => content_type }
             )
         end
@@ -1129,63 +1117,6 @@ describe Ably::Auth do
         end
       end
 
-      context 'when implicit as a result of using :client_id' do
-        let(:client_id) { '999' }
-        let(:client) do
-          Ably::Rest::Client.new(key: api_key, client_id: client_id, environment: environment, protocol: protocol)
-        end
-        let(:token) { 'unique-token' }
-        let(:token_response) do
-          {
-            token: token
-          }.to_json
-        end
-
-        context 'and requests to the Ably server are mocked', :webmock do
-          let!(:request_token_stub) do
-            stub_request(:post, "#{client.endpoint}/keys/#{key_name}/requestToken").
-              to_return(:status => 201, :body => token_response, :headers => { 'Content-Type' => 'application/json' })
-          end
-          let!(:publish_message_stub) do
-            stub_request(:post, "#{client.endpoint}/channels/foo/publish").
-              with(headers: { 'Authorization' => "Bearer #{encode64(token)}" }).
-              to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
-          end
-
-          it 'will send a token request to the server' do
-            client.channel('foo').publish('event', 'data')
-            expect(request_token_stub).to have_been_requested
-          end
-        end
-
-        describe 'a token is created' do
-          let(:token) { client.auth.current_token_details }
-
-          it 'before a request is made' do
-            expect(token).to be_nil
-          end
-
-          it 'when a message is published' do
-            expect(client.channel('foo').publish('event', 'data')).to be_truthy
-          end
-
-          it 'with capability and TTL defaults (#TK2a, #TK2b)' do
-            client.channel('foo').publish('event', 'data')
-
-            expect(token).to be_a(Ably::Models::TokenDetails)
-            capability_with_str_key = { "*" => ["*"] } # Ably default is all capabilities
-            capability = Hash[capability_with_str_key.keys.map(&:to_s).zip(capability_with_str_key.values)]
-            expect(token.capability).to eq(capability)
-            expect(token.expires.to_i).to be_within(2).of(Time.now.to_i + 60 * 60) # Ably default is 1hr
-            expect(token.client_id).to eq(client_id)
-          end
-
-          specify '#client_id contains the client_id' do
-            expect(client.auth.client_id).to eql(client_id)
-          end
-        end
-      end
-
       context 'when token expires' do
         before do
           stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0 # allow token to be used even if about to expire
@@ -1234,6 +1165,24 @@ describe Ably::Auth do
         end
       end
 
+      context 'when token does not expire' do
+        let(:client_options) { default_options.merge(use_token_auth: true, key: api_key, query_time: true) }
+        let(:channel) { client.channels.get(random_str) }
+
+        context 'for the next 2 hours' do
+          let(:local_time) { Time.now - 2 * 60 * 60 }
+
+          before { allow(Time).to receive(:now).and_return(local_time) }
+
+          it 'should not request for the new token (#RSA4b1)' do
+            expect { channel.publish 'event' }.to change { auth.current_token_details }
+            expect do
+              expect { channel.publish 'event' }.not_to change { auth.current_token_details }
+            end.not_to change { auth.current_token_details.expires }
+          end
+        end
+      end
+
       context 'when :client_id is provided in a token' do
         let(:client_id) { '123' }
         let(:token) do

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

@@ -87,8 +87,10 @@ describe Ably::Rest do
         let(:error_response) { '{ "error": { "statusCode": 500, "code": 50000, "message": "Internal error" } }' }
 
         before do
-          stub_request(:get, "#{client.endpoint}/time").
-            to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
+          (client.fallback_hosts.map { |host| "https://#{host}" } + [client.endpoint]).each do |host|
+            stub_request(:get, "#{host}/time")
+              .to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
+          end
         end
 
         it 'should raise a ServerError exception' do
@@ -98,8 +100,10 @@ describe Ably::Rest do
 
       describe '500 server error without a valid JSON response body', :webmock do
         before do
-          stub_request(:get, "#{client.endpoint}/time").
-          to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
+          (client.fallback_hosts.map { |host| "https://#{host}" } + [client.endpoint]).each do |host|
+            stub_request(:get, "#{host}/time").
+            to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
+          end
         end
 
         it 'should raise a ServerError exception' do