ably-rest 0.8.5 → 0.8.6

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.5'
+  VERSION = '0.8.6'
 end

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

@@ -70,15 +70,6 @@ describe Ably::Realtime::Auth, :event_machine do
         end
       end
 
-      context '#token' do
-        let(:client_options) { default_options.merge(token: random_str) }
-
-        it 'contains the current token after auth' do
-          expect(auth.token).to_not be_nil
-          stop_reactor
-        end
-      end
-
       context '#current_token_details' do
         it 'contains the current token after auth' do
           expect(auth.current_token_details).to be_nil
@@ -99,6 +90,7 @@ describe Ably::Realtime::Auth, :event_machine do
       context '#options (auth_options)' do
         let(:auth_url) { "https://echo.ably.io/?type=text" }
         let(:auth_params) { { :body => random_str } }
+        let(:client_options) { default_options.merge(auto_connect: false) }
 
         it 'contains the configured auth options' do
           auth.authorise({}, auth_url: auth_url, auth_params: auth_params) do
@@ -193,6 +185,75 @@ describe Ably::Realtime::Auth, :event_machine do
             stop_reactor
           end
         end
+
+        context 'when implicitly called, with an explicit ClientOptions client_id' do
+          let(:client_id)        { random_str }
+          let(:client_options)   { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id, log_level: :none) }
+          let(:rest_auth_client) { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: 'invalid')) }
+
+          context 'and an incompatible client_id in a TokenDetails object passed to the auth callback' do
+            let(:auth_token_object) { rest_auth_client.auth.request_token }
+
+            it 'rejects a TokenDetails object with an incompatible client_id and raises an exception' do
+              client.connect
+              client.connection.on(:error) do |error|
+                expect(error).to be_a(Ably::Exceptions::IncompatibleClientId)
+                EventMachine.add_timer(0.1) do
+                  expect(client.connection).to be_failed
+                  stop_reactor
+                end
+              end
+            end
+          end
+
+          context 'and an incompatible client_id in a TokenRequest object passed to the auth callback and raises an exception' do
+            let(:auth_token_object) { rest_auth_client.auth.create_token_request }
+
+            it 'rejects a TokenRequests object with an incompatible client_id and raises an exception' do
+              client.connect
+              client.connection.on(:error) do |error|
+                expect(error).to be_a(Ably::Exceptions::IncompatibleClientId)
+                EventMachine.add_timer(0.1) do
+                  expect(client.connection).to be_failed
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+
+        context 'when explicitly called, with an explicit ClientOptions client_id' do
+          let(:auth_proc) do
+            Proc.new do
+              if !@requested
+                @requested = true
+                valid_auth_token
+              else
+                invalid_auth_token
+              end
+            end
+          end
+
+          let(:client_id)          { random_str }
+          let(:client_options)     { default_options.merge(auth_callback: auth_proc, client_id: client_id, log_level: :none) }
+          let(:valid_auth_token)   { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: client_id)).auth.request_token }
+          let(:invalid_auth_token) { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: 'invalid')).auth.request_token }
+
+          context 'and an incompatible client_id in a TokenDetails object passed to the auth callback' do
+            it 'rejects a TokenDetails object with an incompatible client_id and raises an exception' do
+              client.connection.once(:connected) do
+                client.auth.authorise({}, force: true)
+                client.connection.on(:error) do |error|
+                  expect(error).to be_a(Ably::Exceptions::IncompatibleClientId)
+                  EventMachine.add_timer(0.1) do
+                    expect(client.connection).to be_failed
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+        end
       end
 
       context '#authorise_async' do
@@ -216,7 +277,7 @@ describe Ably::Realtime::Auth, :event_machine do
       end
     end
 
-    context '#auth_params' do
+    context '#auth_params_sync' do
       it 'returns the auth params synchronously' do
         expect(auth.auth_params_sync).to be_a(Hash)
         stop_reactor
@@ -232,11 +293,190 @@ describe Ably::Realtime::Auth, :event_machine do
       end
     end
 
-    context '#auth_header' do
+    context '#auth_header_sync' do
       it 'returns an auth header synchronously' do
         expect(auth.auth_header_sync).to be_a(String)
         stop_reactor
       end
     end
+
+    describe '#client_id_validated?' do
+      let(:auth) { Ably::Rest::Client.new(default_options.merge(key: api_key)).auth }
+
+      context 'when using basic auth' do
+        let(:client_options) { default_options.merge(key: api_key) }
+
+        context 'before connected' do
+          it 'is false as basic auth users do not have an identity' do
+            expect(client.auth).to_not be_client_id_validated
+            stop_reactor
+          end
+        end
+
+        context 'once connected' do
+          it 'is true' do
+            client.connection.once(:connected) do
+              expect(client.auth).to be_client_id_validated
+              stop_reactor
+            end
+          end
+
+          it 'contains a validated wildcard client_id' do
+            client.connection.once(:connected) do
+              expect(client.auth.client_id).to eql('*')
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'when using a token string' do
+        context 'with a valid client_id' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: 'present').token) }
+
+          context 'before connected' do
+            it 'is false as identification is not possible from an opaque token string' do
+              expect(client.auth).to_not be_client_id_validated
+              stop_reactor
+            end
+
+            specify '#client_id is nil' do
+              expect(client.auth.client_id).to be_nil
+              stop_reactor
+            end
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+
+            specify '#client_id is populated' do
+              client.connection.once(:connected) do
+                expect(client.auth.client_id).to eql('present')
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with no client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: nil).token) }
+
+          context 'before connected' do
+            it 'is false as identification is not possible from an opaque token string' do
+              expect(client.auth).to_not be_client_id_validated
+              stop_reactor
+            end
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with a wildcard client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: '*').token) }
+
+          context 'before connected' do
+            it 'is false as identification is not possible from an opaque token string' do
+              expect(client.auth).to_not be_client_id_validated
+              stop_reactor
+            end
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      context 'when using a token' do
+        context 'with a client_id' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: 'present')) }
+
+          it 'is true' do
+            expect(client.auth).to be_client_id_validated
+            stop_reactor
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with no client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: nil)) }
+
+          it 'is true' do
+            expect(client.auth).to be_client_id_validated
+            stop_reactor
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with a wildcard client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: '*')) }
+
+          it 'is true' do
+            expect(client.auth).to be_client_id_validated
+            stop_reactor
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      context 'when using a token request with a client_id' do
+        let(:client_options) { default_options.merge(token: auth.create_token_request(client_id: 'present')) }
+
+        it 'is not true as identification is not confirmed until authenticated' do
+          expect(client.auth).to_not be_client_id_validated
+          stop_reactor
+        end
+
+        context 'once connected' do
+          it 'is true as identification is completed following CONNECTED ProtocolMessage' do
+            client.channel('test').publish('a') do
+              expect(client.auth).to be_client_id_validated
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
   end
 end

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

@@ -186,9 +186,19 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
                 messages.next do |next_page_messages|
                   expect(next_page_messages.items.count).to eql(5)
                   expect(next_page_messages.items.map(&:data).uniq.first).to eql(message_before_attach)
-                  expect(next_page_messages).to be_last
 
-                  stop_reactor
+                  if next_page_messages.last?
+                    expect(next_page_messages).to be_last
+                    stop_reactor
+                  else
+                    # If previous page said there is another page it is plausible and correct that
+                    # the next page is empty and then the last, if the limit was satisfied
+                    next_page_messages.next do |empty_page|
+                      expect(empty_page.items.count).to eql(0)
+                      expect(empty_page).to be_last
+                      stop_reactor
+                    end
+                  end
                 end
               end
             end

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

@@ -504,55 +504,143 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
 
+        context 'nil attributes' do
+          context 'when name is nil' do
+            let(:data) { random_str }
+
+            it 'publishes the message without a name attribute in the payload' do
+              published = false
+              channel.publish(nil, data) do
+                published = true
+              end
+
+              channel.subscribe do |message|
+                expect(message.name).to be_nil
+                channel.history do |page|
+                  expect(page.items.first.name).to be_nil
+                  expect(page.items.first.data).to eql(data)
+                  EM.add_timer(0.5) do
+                    expect(published).to eql(true)
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+
+          context 'when data is nil' do
+            let(:name) { random_str }
+
+            it 'publishes the message without a data attribute in the payload' do
+              published = false
+              channel.publish(name, nil) do
+                published = true
+              end
+
+              channel.subscribe do |message|
+                expect(message.data).to be_nil
+                channel.history do |page|
+                  expect(page.items.first.name).to eql(name)
+                  expect(page.items.first.data).to be_nil
+                  EM.add_timer(0.5) do
+                    expect(published).to eql(true)
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+
+          context 'with neither name or data attributes' do
+            let(:name) { random_str }
+
+            it 'publishes the message without any attributes in the payload' do
+              channel.publish(nil) do
+                channel.history do |page|
+                  expect(page.items.first.name).to be_nil
+                  expect(page.items.first.data).to be_nil
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+
         context 'with two invalid message out of 12' do
-          let(:client_options) { default_options.merge(client_id: 'valid') }
+          let(:rest_client)    { Ably::Rest::Client.new(default_options.merge(client_id: 'valid')) }
+
           let(:invalid_messages) do
             2.times.map do |index|
               Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 }, client_id: 'prohibited')
             end
           end
 
-          it 'calls the errback once' do
-            skip 'Waiting for issue #256 to be resolved'
-            channel.publish(messages + invalid_messages).tap do |deferrable|
-              deferrable.callback do
-                raise 'Publish should have failed'
-              end
+          context 'before client_id is known (validated)' do
+            let(:client_options) { default_options.merge(token: rest_client.auth.request_token.token, log_level: :error) }
 
-              deferrable.errback do |error, message|
-                # TODO: Review whether we should fail once or multiple times
-                channel.history do |page|
-                  expect(page.items.count).to eql(0)
-                  stop_reactor
+            it 'calls the errback once' do
+              channel.publish(messages + invalid_messages).tap do |deferrable|
+                deferrable.callback do
+                  raise 'Publish should have failed'
+                end
+
+                deferrable.errback do |error, message|
+                  # TODO: Review whether we should fail once or multiple times
+                  channel.history do |page|
+                    expect(page.items.count).to eql(0)
+                    stop_reactor
+                  end
                 end
               end
             end
           end
+
+          context 'when client_id is known (validated)' do
+            let(:client_options) { default_options.merge(client_id: 'valid') }
+
+            it 'raises an exception' do
+              expect { channel.publish(messages + invalid_messages) }.to raise_error Ably::Exceptions::IncompatibleClientId
+              stop_reactor
+            end
+          end
         end
 
         context 'only invalid messages' do
-          let(:client_options) { default_options.merge(client_id: 'valid') }
+          let(:rest_client)    { Ably::Rest::Client.new(default_options.merge(client_id: 'valid')) }
+
           let(:invalid_messages) do
             10.times.map do |index|
               Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 }, client_id: 'prohibited')
             end
           end
 
-          it 'calls the errback once' do
-            skip 'Waiting for issue #256 to be resolved'
-            channel.publish(invalid_messages).tap do |deferrable|
-              deferrable.callback do
-                raise 'Publish should have failed'
-              end
+          context 'before client_id is known (validated)' do
+            let(:client_options) { default_options.merge(token: rest_client.auth.request_token.token, log_level: :error) }
 
-              deferrable.errback do |error, message|
-                channel.history do |page|
-                  expect(page.items.count).to eql(0)
-                  stop_reactor
+            it 'calls the errback once' do
+              channel.publish(invalid_messages).tap do |deferrable|
+                deferrable.callback do
+                  raise 'Publish should have failed'
+                end
+
+                deferrable.errback do |error, message|
+                  channel.history do |page|
+                    expect(page.items.count).to eql(0)
+                    stop_reactor
+                  end
                 end
               end
             end
           end
+
+          context 'when client_id is known (validated)' do
+            let(:client_options) { default_options.merge(client_id: 'valid') }
+
+            it 'raises an exception' do
+              expect { channel.publish(invalid_messages) }.to raise_error Ably::Exceptions::IncompatibleClientId
+              stop_reactor
+            end
+          end
         end
       end
 
@@ -581,6 +669,208 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
       end
+
+      context 'identified clients' do
+        context 'when authenticated with a wildcard client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { auto_close Ably::Realtime::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'with a valid client_id in the message' do
+            it 'succeeds' do
+              channel.publish([name: 'event', client_id: 'validClient']).tap do |deferrable|
+                deferrable.errback { raise 'Should have succeeded' }
+              end
+              channel.subscribe('event') do |message|
+                expect(message.client_id).to eql('validClient')
+                EM.add_timer(0.5) { stop_reactor }
+              end
+            end
+          end
+
+          context 'with a wildcard client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: '*']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+              stop_reactor
+            end
+          end
+
+          context 'with an empty client_id in the message' do
+            it 'succeeds and publishes without a client_id' do
+              channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                deferrable.errback { raise 'Should have succeeded' }
+              end
+              channel.subscribe('event') do |message|
+                expect(message.client_id).to be_nil
+                EM.add_timer(0.5) { stop_reactor }
+              end
+            end
+          end
+        end
+
+        context 'when authenticated with a Token string with an implicit client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: 'valid').token }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { auto_close Ably::Realtime::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'before the client is CONNECTED and the client\'s identity has been obtained' do
+            context 'with a valid client_id in the message' do
+              it 'succeeds' do
+                channel.publish([name: 'event', client_id: 'valid']).tap do |deferrable|
+                  deferrable.errback { raise 'Should have succeeded' }
+                end
+                channel.subscribe('event') do |message|
+                  expect(message.client_id).to eql('valid')
+                  EM.add_timer(0.5) { stop_reactor }
+                end
+              end
+            end
+
+            context 'with an invalid client_id in the message' do
+              let(:client_options)   { default_options.merge(key: nil, token: token, log_level: :error) }
+              it 'succeeds in the client library but then fails when delivered to Ably' do
+                channel.publish([name: 'event', client_id: 'invalid']).tap do |deferrable|
+                  EM.add_timer(0.5) { stop_reactor }
+                end
+                channel.subscribe('event') do |message|
+                  raise 'Message should not have been published'
+                end
+              end
+            end
+
+            context 'with an empty client_id in the message' do
+              it 'succeeds and publishes with an implicit client_id' do
+                channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                  deferrable.errback { raise 'Should have succeeded' }
+                end
+                channel.subscribe('event') do |message|
+                  expect(message.client_id).to eql('valid')
+                  EM.add_timer(0.5) { stop_reactor }
+                end
+              end
+            end
+          end
+
+          context 'after the client is CONNECTED and the client\'s identity is known' do
+            context 'with a valid client_id in the message' do
+              it 'succeeds' do
+                client.connection.once(:connected) do
+                  channel.publish([name: 'event', client_id: 'valid']).tap do |deferrable|
+                    deferrable.errback { raise 'Should have succeeded' }
+                  end
+                  channel.subscribe('event') do |message|
+                    expect(message.client_id).to eql('valid')
+                    EM.add_timer(0.5) { stop_reactor }
+                  end
+                end
+              end
+            end
+
+            context 'with an invalid client_id in the message' do
+              it 'throws an exception' do
+                client.connection.once(:connected) do
+                  expect { channel.publish([name: 'event', client_id: 'invalid']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+                  stop_reactor
+                end
+              end
+            end
+
+            context 'with an empty client_id in the message' do
+              it 'succeeds and publishes with an implicit client_id' do
+                client.connection.once(:connected) do
+                  channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                    deferrable.errback { raise 'Should have succeeded' }
+                  end
+                  channel.subscribe('event') do |message|
+                    expect(message.client_id).to eql('valid')
+                    EM.add_timer(0.5) { stop_reactor }
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        context 'when authenticated with a valid client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: 'valid') }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { auto_close Ably::Realtime::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'with a valid client_id' do
+            it 'succeeds' do
+              channel.publish([name: 'event', client_id: 'valid']).tap do |deferrable|
+                deferrable.errback { raise 'Should have succeeded' }
+              end
+              channel.subscribe('event') do |message|
+                expect(message.client_id).to eql('valid')
+                EM.add_timer(0.5) { stop_reactor }
+              end
+            end
+          end
+
+          context 'with a wildcard client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: '*']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+              stop_reactor
+            end
+          end
+
+          context 'with an invalid client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: 'invalid']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+              stop_reactor
+            end
+          end
+
+          context 'with an empty client_id in the message' do
+            it 'succeeds and publishes with an implicit client_id' do
+              channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                deferrable.errback { raise 'Should have succeeded' }
+              end
+              channel.subscribe('event') do |message|
+                expect(message.client_id).to eql('valid')
+                EM.add_timer(0.5) { stop_reactor }
+              end
+            end
+          end
+        end
+
+        context 'when anonymous and no client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: nil) }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { auto_close Ably::Realtime::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'with a client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: 'invalid']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+              stop_reactor
+            end
+          end
+
+          context 'with a wildcard client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: '*']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+              stop_reactor
+            end
+          end
+
+          context 'with an empty client_id in the message' do
+            it 'succeeds and publishes with an implicit client_id' do
+              channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                deferrable.errback { raise 'Should have succeeded' }
+              end
+              channel.subscribe('event') do |message|
+                expect(message.client_id).to be_nil
+                EM.add_timer(0.5) { stop_reactor }
+              end
+            end
+          end
+        end
+      end
     end
 
     describe '#subscribe' do
@@ -881,7 +1171,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         context 'a :failed channel' do
           let(:original_error) { RuntimeError.new }
-          let(:client_options)   { default_options.merge(log_level: :fatal) }
+          let(:client_options) { default_options.merge(log_level: :fatal) }
 
           it 'remains in the :failed state and retains the error_reason' do
             channel.attach do
@@ -904,6 +1194,8 @@ describe Ably::Realtime::Channel, :event_machine do
         end
 
         context 'a channel ATTACH request when connection SUSPENDED' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+
           it 'raises an exception' do
             client.connect do
               client.connection.once(:suspended) do