ably 1.1.4.rc → 1.1.4

data/spec/acceptance/realtime/channel_spec.rb

@@ -83,6 +83,16 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
 
+        it 'sets attach_serial property after the attachment (#RTL15a)' do
+          expect(channel.properties.attach_serial).to be_nil
+
+          channel.attach
+          channel.on(:attached) do
+            expect(channel.properties.attach_serial).to_not be_nil
+            stop_reactor
+          end
+        end
+
         it 'sends an ATTACH and waits for an ATTACHED (#RTL4c)' do
           connection.once(:connected) do
             attach_count = 0

data/spec/acceptance/realtime/client_spec.rb

@@ -87,22 +87,6 @@ describe Ably::Realtime::Client, :event_machine do
                 end
               end
             end
-
-            context 'with client_id' do
-              let(:client_options) do
-                default_options.merge(client_id: random_str)
-              end
-              it 'connects using token auth' do
-                run_reactor do
-                  connection.on(:connected) do
-                    expect(connection.state).to eq(:connected)
-                    expect(auth_params[:access_token]).to_not be_nil
-                    expect(auth_params[:key]).to be_nil
-                    stop_reactor
-                  end
-                end
-              end
-            end
           end
         end
 
@@ -249,6 +233,8 @@ describe Ably::Realtime::Client, :event_machine do
 
     context '#request (#RSC19*)' do
       let(:client_options) { default_options.merge(key: api_key) }
+      let(:device_id) { random_str }
+      let(:endpoint) { subject.rest_client.endpoint }
 
       context 'get' do
         it 'returns an HttpPaginatedResponse object' do
@@ -297,6 +283,76 @@ describe Ably::Realtime::Client, :event_machine do
           end
         end
       end
+
+
+      context 'post', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/deviceRegistrations/#{device_id}/resetUpdateToken").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports post' do
+          subject.request(:delete, "push/deviceRegistrations/#{device_id}/resetUpdateToken").callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'delete', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/channelSubscriptions?deviceId=#{device_id}").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports delete' do
+          subject.request(:delete, "/push/channelSubscriptions", { deviceId: device_id}).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'patch', :webmock do
+        let(:body_params) { { 'metadata' => { 'key' => 'value' } } }
+
+        before do
+          stub_request(:patch, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports patch' do
+          subject.request(:patch, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'put', :webmock do
+        let(:body_params) do
+          {
+            'id' => random_str,
+            'platform' => 'ios',
+            'formFactor' => 'phone',
+            'metadata' => { 'key' => 'value' }
+          }
+        end
+
+        before do
+          stub_request(:put, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports put' do
+          subject.request(:put, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
     end
 
     context '#publish (#TBC)' do

data/spec/acceptance/realtime/connection_spec.rb

@@ -77,18 +77,6 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
               end
             end
-
-            context 'with implicit authorisation' do
-              let(:client_options) { default_options.merge(client_id: 'force_token_auth') }
-
-              it 'uses the token created by the implicit authorisation' do
-                expect(client.rest_client.auth).to receive(:request_token).once.and_call_original
-
-                connection.once(:connected) do
-                  stop_reactor
-                end
-              end
-            end
           end
 
           context 'that expire' do
@@ -1879,5 +1867,33 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+    context 'transport_params (#RTC1f)' do
+      let(:client_options) { default_options.merge(transport_params: { 'extra_param' => 'extra_param' }) }
+
+      it 'pases transport_params to query' do
+        expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+            uri = URI.parse(url)
+            expect(CGI::parse(uri.query)['extra_param'][0]).to eq('extra_param')
+            stop_reactor
+          end
+
+          client
+      end
+
+      context 'when changing default param' do
+        let(:client_options) { default_options.merge(transport_params: { v: '1.0' }) }
+
+        it 'overrides default param (#RTC1f1)' do
+          expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+            uri = URI.parse(url)
+            expect(CGI::parse(uri.query)['v'][0]).to eq('1.0')
+            stop_reactor
+          end
+
+          client
+        end
+      end
+    end
   end
 end

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -52,63 +52,5 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
       presence_client_one.enter(data)
     end
-
-    context 'with option until_attach: true' do
-      let(:event) { random_str }
-      let(:presence_data_before_attach) { random_str }
-      let(:presence_data_after_attach) { random_str }
-
-      it 'retrieves all presence messages before channel was attached' do
-        presence_client_two.enter(presence_data_before_attach) do
-          presence_client_one.enter(presence_data_after_attach) do
-            presence_client_one.history(until_attach: true) do |presence_page|
-              expect(presence_page.items.count).to eql(1)
-              expect(presence_page.items.first.data).to eql(presence_data_before_attach)
-              stop_reactor
-            end
-          end
-        end
-      end
-
-      context 'and two pages of messages' do
-        let(:wildcard_token) { lambda { |token_params| Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') } }
-        let(:client_one)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-        let(:client_two)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-
-        # TODO: Remove retry logic when presence history regression fixed
-        #       https://github.com/ably/realtime/issues/1707
-        #
-        it 'retrieves two pages of messages before channel was attached', retry: 10, :retry_wait => 5 do
-          when_all(*10.times.map { |i| presence_client_two.enter_client("client:#{i}", presence_data_before_attach) }) do
-            when_all(*10.times.map { |i| presence_client_one.enter_client("client:#{i}", presence_data_after_attach) }) do
-              presence_client_one.history(until_attach: true, limit: 5) do |presence_page|
-                expect(presence_page.items.count).to eql(5)
-                expect(presence_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-
-                presence_page.next do |presence_next_page|
-                  expect(presence_next_page.items.count).to eql(5)
-                  expect(presence_next_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-                  if presence_next_page.has_next?
-                    presence_next_page.next do |last|
-                      expect(last.items.count).to eql(0)
-                    end
-                  else
-                    expect(presence_next_page).to be_last
-                  end
-                  stop_reactor
-                end
-              end
-            end
-          end
-        end
-      end
-
-      it 'fails with an exception unless state is attached' do
-        presence_client_one.history(until_attach: true).errback do |error|
-          expect(error.message).to match(/not attached/)
-          stop_reactor
-        end
-      end
-    end
   end
 end

data/spec/acceptance/realtime/presence_spec.rb

@@ -2449,6 +2449,60 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      describe '#RTP17b' do
+        let(:leave_action) { Ably::Models::PresenceMessage::ACTION.Leave }
+
+        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
+
+                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
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        end
+
+        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
+
+                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
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, fabricated_leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        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 }

data/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/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