ably 1.1.4.rc → 1.1.7

data/spec/acceptance/rest/push_admin_spec.rb

@@ -89,31 +89,15 @@ describe Ably::Rest::Push::Admin 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.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/shared/client_initializer_behaviour.rb

@@ -69,14 +69,6 @@ shared_examples 'a client initializer' do
         expect { subject }.to raise_error(ArgumentError, /key and key_name or key_secret are mutually exclusive/)
       end
     end
-
-    context 'client_id as only option' do
-      let(:client_options) { { client_id: 'valid' } }
-
-      it 'requires a valid key' do
-        expect { subject }.to raise_error(ArgumentError, /client_id cannot be provided without a complete API key or means to authenticate/)
-      end
-    end
   end
 
   context 'with valid arguments' do
@@ -273,6 +265,137 @@ shared_examples 'a client initializer' do
         end
       end
     end
+
+    context 'environment' do
+      context 'when set without custom fallback hosts configured' do
+        let(:environment) { 'foo' }
+        let(:client_options) { default_options.merge(environment: environment) }
+        let(:default_fallbacks) { %w(a b c d e).map { |id| "#{environment}-#{id}-fallback.ably-realtime.com" } }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'uses the default fallback hosts (#TBC, see https://github.com/ably/wiki/issues/361)' do
+          expect(subject.fallback_hosts.sort).to eql(default_fallbacks)
+        end
+      end
+
+      context 'when set with custom fallback hosts configured' do
+        let(:environment) { 'foo' }
+        let(:custom_fallbacks) { %w(a b c).map { |id| "#{environment}-#{id}.foo.com" } }
+        let(:client_options) { default_options.merge(environment: environment, fallback_hosts: custom_fallbacks) }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'uses the custom provided fallback hosts (#RSC15a)' do
+          expect(subject.fallback_hosts.sort).to eql(custom_fallbacks)
+        end
+      end
+
+      context 'when set with fallback_hosts_use_default' do
+        let(:environment) { 'foo' }
+        let(:custom_fallbacks) { %w(a b c).map { |id| "#{environment}-#{id}.foo.com" } }
+        let(:default_production_fallbacks) { %w(a b c d e).map { |id| "#{id}.ably-realtime.com" } }
+        let(:client_options) { default_options.merge(environment: environment, fallback_hosts_use_default: true) }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'uses the production default fallback hosts (#RTN17b)' do
+          expect(subject.fallback_hosts.sort).to eql(default_production_fallbacks)
+        end
+      end
+    end
+
+    context 'rest_host' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_rest_host) { 'foo.com' }
+        let(:client_options) { default_options.merge(rest_host: custom_rest_host) }
+
+        it 'sets the custom_host attribute' do
+          expect(subject.custom_host).to eql(custom_rest_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+
+      context 'when set with environment and without custom fallback hosts configured' do
+        let(:environment) { 'foobar' }
+        let(:custom_rest_host) { 'foo.com' }
+        let(:client_options) { default_options.merge(environment: environment, rest_host: custom_rest_host) }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'sets the custom_host attribute' do
+          expect(subject.custom_host).to eql(custom_rest_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+
+      context 'when set with custom fallback hosts configured' do
+        let(:custom_rest_host) { 'foo.com' }
+        let(:custom_fallbacks) { %w(a b c).map { |id| "#{environment}-#{id}.foo.com" } }
+        let(:client_options) { default_options.merge(rest_host: custom_rest_host, fallback_hosts: custom_fallbacks) }
+
+        it 'sets the custom_host attribute' do
+          expect(subject.custom_host).to eql(custom_rest_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts.sort).to eql(custom_fallbacks)
+        end
+      end
+    end
+
+    context 'realtime_host' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_realtime_host) { 'realtime.foo.com' }
+        let(:client_options) { default_options.merge(realtime_host: custom_realtime_host) }
+
+        # These tests are shared between realtime & rest clients
+        # So don't test for the attribute, instead test the options
+        it 'sets the realtime_host option' do
+          expect(subject.options[:realtime_host]).to eql(custom_realtime_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+    end
+
+    context 'custom port' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_port) { 555 }
+        let(:client_options) { default_options.merge(port: custom_port) }
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+    end
+
+    context 'custom TLS port' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_port) { 555 }
+        let(:client_options) { default_options.merge(tls_port: custom_port) }
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+    end
   end
 
   context 'delegators' do

data/spec/shared/model_behaviour.rb

@@ -19,7 +19,7 @@ shared_examples 'a model' do |shared_options = {}|
     end
 
     context '#attributes', :api_private do
-      let(:model_options) { { action: 5 } }
+      let(:model_options) { { action: 5, max_message_size: 65536, max_frame_size: 524288 } }
 
       it 'provides access to #attributes' do
         expect(model.attributes).to eq(model_options)

data/spec/spec_helper.rb

@@ -5,8 +5,17 @@ def console(message)
 end
 
 unless RUBY_VERSION.match(/^1\./)
-  require 'coveralls'
-  Coveralls.wear!
+  require 'simplecov'
+
+  SimpleCov.start do
+    require 'simplecov-lcov'
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
+    formatter SimpleCov::Formatter::LcovFormatter
+    add_filter %w[vendor spec]
+  end
 end
 
 require 'webmock/rspec'
@@ -19,6 +28,7 @@ require 'support/event_emitter_helper'
 require 'support/private_api_formatter'
 require 'support/protocol_helper'
 require 'support/random_helper'
+require 'support/serialization_helper'
 require 'support/test_logger_helper'
 
 require 'rspec_config'

data/spec/support/serialization_helper.rb

@@ -0,0 +1,21 @@
+module SerializationHelper
+  def serialize_body(object, protocol)
+    if protocol == :msgpack
+      MessagePack.pack(object)
+    else
+      JSON.dump(object)
+    end
+  end
+
+  def deserialize_body(object, protocol)
+    if protocol == :msgpack
+      MessagePack.unpack(object)
+    else
+      JSON.parse(object)
+    end
+  end
+
+  RSpec.configure do |config|
+    config.include self
+  end
+end

data/spec/unit/models/message_spec.rb

@@ -211,6 +211,65 @@ describe Ably::Models::Message do
     end
   end
 
+  describe '#size' do
+    let(:model) { subject.new({ name: name, data: data, client_id: client_id, extras: extras }, protocol_message: protocol_message) }
+
+    context 'String (#TO3l8a)' do
+      let(:data) { 'example string data' }
+      let(:client_id) { '1' }
+      let(:name) { 'My Name' }
+      let(:extras) { 'extras' }
+
+      it 'should return 33 bytes' do
+        expect(model.size).to eq(33)
+      end
+    end
+
+    context 'Object (#TO3l8b)' do
+      let(:data) { Object.new }
+      let(:client_id) { String('10') }
+      let(:name) { 'John' }
+      let(:extras) { Hash.new }
+
+      it 'should return 38 bytes' do
+        expect(model.size).to eq(38)
+      end
+    end
+
+    context 'Array (#TO3l8b)' do
+      let(:data) { [1, 'two', :three] }
+      let(:client_id) { '2' }
+      let(:name) { 'Kate' }
+      let(:extras) { [] }
+
+      it 'should return 24 bytes' do
+        expect(model.size).to eq(24)
+      end
+    end
+
+    context 'extras (#TO3l8d)' do
+      let(:data) { { example: 'value', score: 1, hash: { test: true } } }
+      let(:client_id) { '3' }
+      let(:name) { 'John' }
+      let(:extras) { {} }
+
+      it 'should return 57 bytes' do
+        expect(model.size).to eq(57)
+      end
+    end
+
+    context 'nil (#TO3l8e)' do
+      let(:data) { nil }
+      let(:client_id) { '' }
+      let(:name) { '' }
+      let(:extras) { nil}
+
+      it 'should return 19 bytes' do
+        expect(model.size).to eq(0)
+      end
+    end
+  end
+
   context 'from REST request with embedded fields', :api_private do
     let(:id)                  { random_str }
     let(:protocol_message_id) { random_str }

data/spec/unit/models/presence_message_spec.rb

@@ -220,6 +220,55 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
+  describe '#size' do
+    let(:model) { subject.new({ action: 'enter', data: data, client_id: client_id }, protocol_message: protocol_message) }
+
+    context 'String (#TO3l8a)' do
+      let(:data) { 'example string data' }
+      let(:client_id) { '1' }
+
+      it 'should return 20 bytes' do
+        expect(model.size).to eq(20)
+      end
+    end
+
+    context 'Object (#TO3l8b)' do
+      let(:data) { Object.new }
+      let(:client_id) { '10' }
+
+      it 'should return 32 bytes' do
+        expect(model.size).to eq(32)
+      end
+    end
+
+    context 'Array (#TO3l8b)' do
+      let(:data) { [1, 'two', :three] }
+      let(:client_id) { '2' }
+
+      it 'should return 18 bytes' do
+        expect(model.size).to eq(18)
+      end
+    end
+
+    context 'extras (#TO3l8d)' do
+      let(:data) { { example: 'value', score: 1, hash: { test: true } } }
+      let(:client_id) { '3' }
+
+      it 'should return 51 bytes' do
+        expect(model.size).to eq(51)
+      end
+    end
+
+    context 'nil (#TO3l8e)' do
+      let(:data) { nil }
+      let(:client_id) { '4' }
+
+      it 'should return 1 bytes' do
+        expect(model.size).to eq(1)
+      end
+    end
+  end
+
   context 'from REST request with embedded fields', :api_private do
     let(:id) { random_str }
     let(:message_time) { Time.now + 60 }

data/spec/unit/models/protocol_message_spec.rb

@@ -318,6 +318,54 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
+    context '#message_size (#TO3l8)' do
+      context 'on presence' do
+        let(:protocol_message) do
+          new_protocol_message(presence: [{ action: 1, data: 'test342343', client_id: 'sdf' }])
+        end
+
+        it 'should return 13 bytes (sum in bytes: data and client_id)' do
+          expect(protocol_message.message_size).to eq(13)
+        end
+      end
+
+      context 'on message' do
+        let(:protocol_message) do
+          new_protocol_message(messages: [{ action: 1, unknown: 'test', data: 'test342343', client_id: 'sdf', name: 'sf23ewrew', extras: { time: Time.now, time_zone: 'UTC' } }])
+        end
+
+        it 'should return 76 bytes (sum in bytes: data, client_id, name, extras)' do
+          expect(protocol_message.message_size).to eq(76)
+        end
+      end
+    end
+
+    context '#has_correct_message_size? (#TO3l8)' do
+      context 'on presence' do
+        it 'should return true when a message has correct size' do
+          protocol_message = new_protocol_message(presence: [{ action: 1, data: 'x' * 100 }])
+          expect(protocol_message.has_correct_message_size?).to eq(true)
+        end
+
+        it 'should return false when a message has not correct size' do
+          protocol_message = new_protocol_message(presence: [{ action: 1, data: 'x' * 65537 }])
+          expect(protocol_message.has_correct_message_size?).to eq(false)
+        end
+      end
+
+      context 'on message' do
+        it 'should return true when a message has correct size' do
+          protocol_message = new_protocol_message(messages: [{ name: 'x' * 100 }])
+          expect(protocol_message.has_correct_message_size?).to eq(true)
+        end
+
+        it 'should return false when a message has not correct size' do
+          protocol_message = new_protocol_message(messages: [{ name: 'x' * 65537 }])
+          expect(protocol_message.has_correct_message_size?).to eq(false)
+        end
+      end
+    end
+
     context '#connection_details (#TR4o)' do
       let(:connection_details) { protocol_message.connection_details }
 

data/spec/unit/realtime/channel_spec.rb

@@ -68,7 +68,7 @@ describe Ably::Realtime::Channel do
 
   describe '#publish name argument' do
     let(:encoded_value) { random_str.encode(encoding) }
-    let(:message) { instance_double('Ably::Models::Message', client_id: nil) }
+    let(:message) { instance_double('Ably::Models::Message', client_id: nil, size: 0) }
 
     before do
       allow(subject).to receive(:create_message).and_return(message)

data/spec/unit/realtime/client_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'shared/client_initializer_behaviour'
 
 describe Ably::Realtime::Client do
-  subject do
+  subject(:realtime_client) do
     Ably::Realtime::Client.new(client_options)
   end
 
@@ -15,28 +15,41 @@ describe Ably::Realtime::Client do
     it 'passes on the options to the initializer' do
       rest_client = instance_double('Ably::Rest::Client', auth: instance_double('Ably::Auth'), options: client_options, environment: 'production', use_tls?: true, custom_tls_port: nil)
       expect(Ably::Rest::Client).to receive(:new).with(hash_including(client_options)).and_return(rest_client)
-      subject
+      realtime_client
     end
 
     context 'for attribute' do
       [:environment, :use_tls?, :log_level, :custom_host].each do |attribute|
         specify "##{attribute}" do
-          expect(subject.rest_client).to receive(attribute)
-          subject.public_send attribute
+          expect(realtime_client.rest_client).to receive(attribute)
+          realtime_client.public_send attribute
         end
       end
     end
   end
 
+  context 'when :transport_params option is passed' do
+    let(:expected_transport_params) do
+      { 'heartbeats' => 'true', 'v' => '1.0', 'extra_param' => 'extra_param' }
+    end
+    let(:client_options) do
+      { key: 'appid.keyuid:keysecret', transport_params: { heartbeats: true, v: 1.0, extra_param: 'extra_param'} }
+    end
+
+    it 'converts options to strings' do
+      expect(realtime_client.transport_params).to eq(expected_transport_params)
+    end
+  end
+
   context 'push' do
     let(:client_options) { { key: 'appid.keyuid:keysecret' } }
 
     specify '#device is not supported and raises an exception' do
-      expect { subject.device }.to raise_error Ably::Exceptions::PushNotificationsNotSupported
+      expect { realtime_client.device }.to raise_error Ably::Exceptions::PushNotificationsNotSupported
     end
 
     specify '#push returns a Push object' do
-      expect(subject.push).to be_a(Ably::Realtime::Push)
+      expect(realtime_client.push).to be_a(Ably::Realtime::Push)
     end
   end