ably 0.8.5 → 0.8.6

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

data/spec/acceptance/realtime/client_spec.rb

@@ -53,7 +53,7 @@ describe Ably::Realtime::Client, :event_machine do
                 connection.on(:connected) do
                   expect(auth_params[:access_token]).to_not be_nil
                   expect(auth_params[:key]).to be_nil
-                  expect(subject.auth.current_token_details).to be_nil
+                  expect(subject.auth.current_token_details).to be_a(Ably::Models::TokenDetails)
                   stop_reactor
                 end
               end
@@ -113,6 +113,98 @@ describe Ably::Realtime::Client, :event_machine do
               stop_reactor
             end
           end
+
+          context 'when the returned token has a client_id' do
+            it "sets Auth#client_id to the new token's client_id immediately when connecting" do
+              subject.auth.authorise do
+                expect(subject.connection).to be_connecting
+                expect(subject.auth.client_id).to eql(client_id)
+                stop_reactor
+              end
+            end
+
+            it "sets Client#client_id to the new token's client_id immediately when connecting" do
+              subject.auth.authorise do
+                expect(subject.connection).to be_connecting
+                expect(subject.client_id).to eql(client_id)
+                stop_reactor
+              end
+            end
+          end
+
+          context 'with a wildcard client_id token' do
+            subject                 { auto_close Ably::Realtime::Client.new(client_options) }
+            let(:client_options)    { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id) }
+            let(:rest_auth_client)  { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
+            let(:auth_token_object) { rest_auth_client.auth.request_token(client_id: '*') }
+
+            context 'and an explicit client_id in ClientOptions' do
+              let(:client_id) { random_str }
+
+              it 'allows uses the explicit client_id in the connection' do
+                connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :connected
+                    expect(protocol_message.connection_details.client_id).to eql(client_id)
+                    @valid_client_id = true
+                  end
+                end
+                subject.connect do
+                  EM.add_timer(0.5) { stop_reactor if @valid_client_id }
+                end
+              end
+            end
+
+            context 'and client_id omitted in ClientOptions' do
+              let(:client_options) { default_options.merge(auth_callback: Proc.new { auth_token_object }) }
+
+              it 'uses the token provided clientId in the connection' do
+                connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :connected
+                    expect(protocol_message.connection_details.client_id).to eql('*')
+                    @valid_client_id = true
+                  end
+                end
+                subject.connect do
+                  EM.add_timer(0.5) { stop_reactor if @valid_client_id }
+                end
+              end
+            end
+          end
+        end
+
+        context 'with an invalid wildcard "*" :client_id' do
+          it 'raises an exception' do
+            expect { Ably::Realtime::Client.new(client_options.merge(key: api_key, client_id: '*')) }.to raise_error ArgumentError
+            stop_reactor
+          end
+        end
+      end
+
+      context 'realtime connection settings' do
+        context 'defaults' do
+          specify 'disconnected_retry_timeout is 15s' do
+            expect(subject.connection.defaults[:disconnected_retry_timeout]).to eql(15)
+            stop_reactor
+          end
+
+          specify 'suspended_retry_timeout is 30s' do
+            expect(subject.connection.defaults[:suspended_retry_timeout]).to eql(30)
+            stop_reactor
+          end
+        end
+
+        context 'overriden in ClientOptions' do
+          let(:client_options) { default_options.merge(disconnected_retry_timeout: 1, suspended_retry_timeout: 2) }
+
+          specify 'disconnected_retry_timeout is updated' do
+            expect(subject.connection.defaults[:disconnected_retry_timeout]).to eql(1)
+            stop_reactor
+          end
+
+          specify 'suspended_retry_timeout is updated' do
+            expect(subject.connection.defaults[:suspended_retry_timeout]).to eql(2)
+            stop_reactor
+          end
         end
       end
     end