ably 1.0.7 → 1.1.0

data/spec/acceptance/rest/push_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Push do
+  vary_by_protocol do
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:client_options)  { default_options }
+    let(:client) do
+      Ably::Rest::Client.new(client_options)
+    end
+    subject { client.push }
+
+    describe '#activate' do
+      it 'raises an unsupported exception' do
+        expect { subject.activate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+      end
+    end
+
+    describe '#deactivate' do
+      it 'raises an unsupported exception' do
+        expect { subject.deactivate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+      end
+    end
+  end
+end

data/spec/acceptance/rest/time_spec.rb

@@ -13,7 +13,7 @@ describe Ably::Rest::Client, '#time' do
 
       context 'with reconfigured HTTP timeout' do
         let(:client) do
-          Ably::Rest::Client.new(http_request_timeout: 0.0001, key: api_key, environment: environment, protocol: protocol)
+          Ably::Rest::Client.new(http_request_timeout: 0.0001, key: api_key, environment: environment, protocol: protocol, log_retries_as_info: true)
         end
 
         it 'should raise a timeout exception' do

data/spec/run_parallel_tests

@@ -0,0 +1,33 @@
+#!/bin/bash
+#
+# Run the unit tests first without RSpec parallel, then run acceptance tests in parallel
+#
+# When splitting all tests across all parallel processes, it's quite plausible
+# that some processes only run a majority of unit tests, whilst others only run a
+# a majority of acceptance tests. This ensures acceptance tests are split out.
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
+
+bundle exec rspec "${DIR}/unit"
+unit_status=$?
+
+if ruby -v | grep -e "1.9"; then
+  # Output with test ID is not supported with this old version of RSpec
+  # So it will be jumbled sadly for 1.9.*
+  bundle exec parallel_rspec "${DIR}/acceptance"
+else
+  bundle exec parallel_rspec "${DIR}/acceptance" --prefix-output-with-test-env-number
+fi
+acceptance_status=$?
+
+if [ $unit_status -ne 0 ]; then
+  echo -e "\e[31m⚠ Note: Unit tests have also failed, but are not listed in the test failures above. Scroll up to the unit tests ⚠\e[0m"
+fi
+
+if [ $unit_status -ne 0 ] || [ $acceptance_status -ne 0 ]; then
+  echo "Unit tests exit code: ${unit_status}"
+  echo "Acceptance tests exit code: ${acceptance_status}"
+  exit 1
+fi
+
+

data/spec/unit/logger_spec.rb

@@ -17,11 +17,15 @@ describe Ably::Logger do
   end
 
   context 'internals', :api_private do
-    it 'delegates to the logger object' do
-      expect(subject.logger).to receive(:warn) do |*args, &block|
+    it 'delegates to the default Logger object' do
+      received = false
+      expect(subject.logger).to be_a(::Logger)
+      allow_any_instance_of(::Logger).to receive(:warn) do |*args, &block|
         expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
+        received = true
       end
       subject.warn 'message'
+      expect(received).to be_truthy
     end
 
     context 'formatter' do
@@ -132,10 +136,13 @@ describe Ably::Logger do
       end
 
       it 'delegates log messages to logger', :api_private do
-        expect(custom_logger_object).to receive(:fatal) do |*args, &block|
+        received = false
+        allow(custom_logger_object).to receive(:fatal) do |*args, &block|
           expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
+          received = true
         end
         subject.fatal 'message'
+        expect(received).to be_truthy
       end
     end
   end

data/spec/unit/models/device_details_spec.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::DeviceDetails do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::DeviceDetails }
+
+  %w(id platform form_factor client_id device_secret).each do |string_attribute|
+    let(:empty_device_details) { subject.new }
+
+    describe "##{string_attribute} and ##{string_attribute}=" do
+      let(:new_val) { random_str }
+
+      specify 'setter accepts a string value and getter returns the new value' do
+        expect(empty_device_details.public_send(string_attribute)).to be_nil
+        empty_device_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_device_details.public_send(string_attribute)).to eql(new_val)
+      end
+
+      specify 'setter accepts nil' do
+        empty_device_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_device_details.public_send(string_attribute)).to eql(new_val)
+        empty_device_details.public_send("#{string_attribute}=", nil)
+        expect(empty_device_details.public_send(string_attribute)).to be_nil
+      end
+
+      specify 'rejects non string or nil values' do
+        expect { empty_device_details.public_send("#{string_attribute}=", {}) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'camelCase constructor attributes' do
+    let(:client_id) { random_str }
+    let(:device_details) { subject.new("clientId" => client_id ) }
+
+    specify 'are rubyfied and exposed as underscore case' do
+      expect(device_details.client_id).to eql(client_id)
+    end
+
+    specify 'are generated when the object is serialised to JSON' do
+      expect(JSON.parse(device_details.to_json)["clientId"]).to eql(client_id)
+    end
+  end
+
+  describe "#metadata and #metadata=" do
+    let(:new_val) { { foo: random_str } }
+
+    specify 'setter accepts a Hash value and getter returns the new value' do
+      expect(empty_device_details.metadata).to eql({})
+      empty_device_details.metadata = new_val
+      expect(empty_device_details.metadata.to_json).to eql(new_val.to_json)
+    end
+
+    specify 'setter accepts nil but always returns an empty hash' do
+      empty_device_details.metadata = new_val
+      expect(empty_device_details.metadata.to_json).to eql(new_val.to_json)
+      empty_device_details.metadata = nil
+      expect(empty_device_details.metadata).to eql({})
+    end
+
+    specify 'rejects non Hash or nil values' do
+      expect { empty_device_details.metadata = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#push and #push=" do
+    let(:transport_type) { random_str }
+    let(:new_val) { { recipient: { transport_type: transport_type } } }
+    let(:json_val) { { recipient: { transportType: transport_type } }.to_json }
+
+    specify 'setter accepts a DevicePushDetails object and getter returns a DevicePushDetails object' do
+      expect(empty_device_details.push.to_json).to eql({}.to_json)
+      empty_device_details.push = DevicePushDetails(new_val)
+      expect(empty_device_details.push).to be_a(Ably::Models::DevicePushDetails)
+      expect(empty_device_details.push.recipient[:transport_type]).to eql(transport_type)
+      expect(empty_device_details.push.to_json).to eql(json_val)
+    end
+
+    specify 'setter accepts a Hash value and getter returns a DevicePushDetails object' do
+      expect(empty_device_details.push.to_json).to eql({}.to_json)
+      empty_device_details.push = new_val
+      expect(empty_device_details.push).to be_a(Ably::Models::DevicePushDetails)
+      expect(empty_device_details.push.recipient[:transport_type]).to eql(transport_type)
+      expect(empty_device_details.push.to_json).to eql(json_val)
+    end
+
+    specify 'setter accepts nil but always returns a DevicePushDetails object' do
+      empty_device_details.push = new_val
+      expect(empty_device_details.push.to_json).to eql(json_val)
+      empty_device_details.push = nil
+      expect(empty_device_details.push).to be_a(Ably::Models::DevicePushDetails)
+      expect(empty_device_details.push.to_json).to eql({}.to_json)
+    end
+
+    specify 'rejects non Hash, DevicePushDetails or nil values' do
+      expect { empty_device_details.metadata = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/unit/models/device_push_details_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::DevicePushDetails do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::DevicePushDetails }
+
+  %w(state).each do |string_attribute|
+    let(:empty_push_details) { subject.new }
+
+    describe "##{string_attribute} and ##{string_attribute}=" do
+      let(:new_val) { random_str }
+
+      specify 'setter accepts a string value and getter returns the new value' do
+        expect(empty_push_details.public_send(string_attribute)).to be_nil
+        empty_push_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_push_details.public_send(string_attribute)).to eql(new_val)
+      end
+
+      specify 'setter accepts nil' do
+        empty_push_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_push_details.public_send(string_attribute)).to eql(new_val)
+        empty_push_details.public_send("#{string_attribute}=", nil)
+        expect(empty_push_details.public_send(string_attribute)).to be_nil
+      end
+
+      specify 'rejects non string or nil values' do
+        expect { empty_push_details.public_send("#{string_attribute}=", {}) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'camelCase constructor attributes' do
+    let(:transport_type) { random_str }
+    let(:push_details) { subject.new('errorReason' => { 'message' => 'foo' }, 'recipient' => { 'transportType' => transport_type }) }
+
+    specify 'are rubyfied and exposed as underscore case' do
+      expect(push_details.recipient[:transport_type]).to eql(transport_type)
+      expect(push_details.error_reason.message).to eql('foo')
+    end
+
+    specify 'are generated when the object is serialised to JSON' do
+      expect(JSON.parse(push_details.to_json)['recipient']['transportType']).to eql(transport_type)
+    end
+  end
+
+  describe "#recipient and #recipient=" do
+    let(:new_val) { { foo: random_str } }
+
+    specify 'setter accepts a Hash value and getter returns the new value' do
+      expect(empty_push_details.recipient).to eql({})
+      empty_push_details.recipient = new_val
+      expect(empty_push_details.recipient.to_json).to eql(new_val.to_json)
+    end
+
+    specify 'setter accepts nil but always returns an empty hash' do
+      empty_push_details.recipient = new_val
+      expect(empty_push_details.recipient.to_json).to eql(new_val.to_json)
+      empty_push_details.recipient = nil
+      expect(empty_push_details.recipient).to eql({})
+    end
+
+    specify 'rejects non Hash or nil values' do
+      expect { empty_push_details.recipient = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#error_reason and #error_reason=" do
+    let(:error_message) { random_str }
+    let(:error_attributes) { { message: error_message } }
+
+    specify 'setter accepts a ErrorInfo object and getter returns a ErrorInfo object' do
+      expect(empty_push_details.error_reason).to be_nil
+      empty_push_details.error_reason = ErrorInfo(error_attributes)
+      expect(empty_push_details.error_reason).to be_a(Ably::Models::ErrorInfo)
+      expect(empty_push_details.error_reason.message).to eql(error_message)
+      expect(empty_push_details.error_reason.to_json).to eql(error_attributes.to_json)
+    end
+
+    specify 'setter accepts a Hash value and getter returns a ErrorInfo object' do
+      expect(empty_push_details.error_reason).to be_nil
+      empty_push_details.error_reason = error_attributes
+      expect(empty_push_details.error_reason).to be_a(Ably::Models::ErrorInfo)
+      expect(empty_push_details.error_reason.message).to eql(error_message)
+      expect(empty_push_details.error_reason.to_json).to eql(error_attributes.to_json)
+    end
+
+    specify 'setter accepts nil values' do
+      empty_push_details.error_reason = error_attributes
+      expect(empty_push_details.error_reason.to_json).to eql(error_attributes.to_json)
+      empty_push_details.error_reason = nil
+      expect(empty_push_details.error_reason).to be_nil
+    end
+
+    specify 'rejects non Hash, ErrorInfo or nil values' do
+      expect { empty_push_details.error_reason = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/unit/models/error_info_spec.rb

@@ -4,15 +4,63 @@ require 'shared/model_behaviour'
 describe Ably::Models::ErrorInfo do
   subject { Ably::Models::ErrorInfo }
 
-  it_behaves_like 'a model', with_simple_attributes: %w(code status_code message) do
-    let(:model_args) { [] }
+  context '#TI1, #TI4' do
+    it_behaves_like 'a model', with_simple_attributes: %w(code status_code href message) do
+      let(:model_args) { [] }
+    end
   end
 
-  context '#status' do
+  context '#status #TI1, #TI2' do
     subject { Ably::Models::ErrorInfo.new('statusCode' => 401) }
     it 'is an alias for #status_code' do
       expect(subject.status).to eql(subject.status_code)
       expect(subject.status).to eql(401)
     end
   end
+
+  context 'log entries container help link #TI5' do
+    context 'without an error code' do
+      subject { Ably::Models::ErrorInfo.new('statusCode' => 401) }
+
+      it 'does not include the help URL' do
+        expect(subject.to_s.scan(/help\.ably\.io/)).to be_empty
+      end
+    end
+
+    context 'with a specified error code' do
+      subject { Ably::Models::ErrorInfo.new('code' => 44444) }
+
+      it 'includes https://help.ably.io/error/[CODE] in the stringified object' do
+        expect(subject.to_s).to include('https://help.ably.io/error/44444')
+      end
+    end
+
+    context 'with an error code and an href attribute' do
+      subject { Ably::Models::ErrorInfo.new('code' => 44444, 'href' => 'http://foo.bar.com/') }
+
+      it 'includes the specified href in the stringified object' do
+        expect(subject.to_s).to include('http://foo.bar.com/')
+        expect(subject.to_s).to_not include('https://help.ably.io/error/44444')
+      end
+    end
+
+    context 'with an error code and a message with the same error URL' do
+      subject { Ably::Models::ErrorInfo.new('message' => 'error https://help.ably.io/error/44444', 'code' => 44444) }
+
+      it 'includes the specified error URL only once in the stringified object' do
+        expect(subject.to_s.scan(/help.ably.io/).length).to eql(1)
+      end
+    end
+
+    context 'with an error code and a message with a different error URL' do
+      subject { Ably::Models::ErrorInfo.new('message' => 'error https://help.ably.io/error/123123', 'code' => 44444) }
+
+      it 'includes the specified error URL from the message and the error code URL in the stringified object' do
+        puts subject.to_s
+        expect(subject.to_s.scan(/help.ably.io/).length).to eql(2)
+        expect(subject.to_s.scan(%r{error/123123}).length).to eql(1)
+        expect(subject.to_s.scan(%r{error/44444}).length).to eql(1)
+      end
+    end
+  end
 end

data/spec/unit/models/message_spec.rb

@@ -12,8 +12,23 @@ describe Ably::Models::Message do
   let(:protocol_message_timestamp) { as_since_epoch(Time.now) }
   let(:protocol_message) { Ably::Models::ProtocolMessage.new(action: 1, timestamp: protocol_message_timestamp) }
 
-  it_behaves_like 'a model', with_simple_attributes: %w(id name client_id data encoding) do
-    let(:model_args) { [protocol_message: protocol_message] }
+  context 'serialization of the Message object (#RSL1j)' do
+    it_behaves_like 'a model', with_simple_attributes: %w(id name client_id data encoding) do
+      let(:model_args) { [protocol_message: protocol_message] }
+    end
+  end
+
+  context '#id (#RSL1j)' do
+    let(:id) { random_str }
+    let(:model) { subject.new(id: id) }
+
+    it 'exposes the #id attribute' do
+      expect(model.id).to eql(id)
+    end
+
+    specify '#as_json exposes the #id attribute' do
+      expect(model.as_json['id']).to eql(id)
+    end
   end
 
   context '#timestamp' do

data/spec/unit/models/presence_message_spec.rb

@@ -547,7 +547,7 @@ describe Ably::Models::PresenceMessage do
         clone = model.shallow_clone(id: 'newId', action: 1, timestamp: protocol_message_timestamp + 1000)
         expect(clone.id).to match(/newId/)
         expect(clone.connection_id).to eql(protocol_connection_id)
-        expect(as_since_epoch(clone.timestamp)).to eq(protocol_message_timestamp + 1000)
+        expect(as_since_epoch(clone.timestamp)).to be_within(5).of(protocol_message_timestamp + 1000)
         expect(clone.action).to eq(1)
       end
 

data/spec/unit/models/push_channel_subscription_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::PushChannelSubscription do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::PushChannelSubscription }
+
+  %w(channel client_id device_id).each do |string_attribute|
+    describe "##{string_attribute} and ##{string_attribute}=" do
+      let(:empty_device_details) do
+        if string_attribute == 'device_id'
+          subject.new(channel: 'default', device_id: 'default')
+        else
+          subject.new(channel: 'default', client_id: 'default')
+        end
+      end
+      let(:new_val) { random_str }
+
+      specify 'setter accepts a string value and getter returns the new value' do
+        expect(empty_device_details.public_send(string_attribute)).to eql('default')
+        empty_device_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_device_details.public_send(string_attribute)).to eql(new_val)
+      end
+
+      specify 'setter accepts nil' do
+        empty_device_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_device_details.public_send(string_attribute)).to eql(new_val)
+        empty_device_details.public_send("#{string_attribute}=", nil)
+        expect(empty_device_details.public_send(string_attribute)).to be_nil
+      end
+
+      specify 'rejects non string or nil values' do
+        expect { empty_device_details.public_send("#{string_attribute}=", {}) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'camelCase constructor attributes' do
+    let(:client_id) { random_str }
+    let(:device_details) { subject.new(channel: 'foo', 'clientId' => client_id ) }
+
+    specify 'are rubyfied and exposed as underscore case' do
+      expect(device_details.client_id).to eql(client_id)
+    end
+
+    specify 'are generated when the object is serialised to JSON' do
+      expect(JSON.parse(device_details.to_json)["clientId"]).to eql(client_id)
+    end
+  end
+
+  describe 'conversion method PushChannelSubscription' do
+    let(:channel) { 'foo' }
+    let(:device_id) { 'bar' }
+
+    it 'accepts a PushChannelSubscription object' do
+      push_channel_sub = PushChannelSubscription(channel: channel, device_id: device_id)
+      expect(push_channel_sub.channel).to eql('foo')
+      expect(push_channel_sub.client_id).to be_nil
+      expect(push_channel_sub.device_id).to eql('bar')
+    end
+  end
+
+  describe '#for_client_id constructor' do
+    context 'with a valid object' do
+      let(:channel) { 'foo' }
+      let(:client_id) { 'bob' }
+
+      it 'accepts a Hash object' do
+        push_channel_sub = Ably::Models::PushChannelSubscription.for_client_id(channel, client_id)
+        expect(push_channel_sub.channel).to eql('foo')
+        expect(push_channel_sub.client_id).to eql('bob')
+        expect(push_channel_sub.device_id).to be_nil
+      end
+    end
+
+    context 'with an invalid valid object' do
+      let(:subscription) { { channel: 'foo' } }
+
+      it 'accepts a Hash object' do
+        expect { Ably::Models::PushChannelSubscription.for_device(subscription) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end